n8n-nodes-imap-advanced 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maxime Olivier
+
+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,157 @@
+# n8n-nodes-imap-advanced
+
+Advanced, **generic IMAP** community nodes for n8n (Mailcow, Dovecot, Gmail IMAP, Outlook IMAP, etc.).
+
+This package is focused on practical email automation patterns that are hard to build with the default n8n email nodes alone:
+
+- message threading from headers (`References`, `In-Reply-To`)
+- robust flag/tag updates (including custom IMAP keywords)
+- optional attachment download as n8n binary data
+- trigger with `auto | idle | poll` behavior
+
+---
+
+## Included nodes
+
+### 1) IMAP Advanced
+Resource-based action node with these operations:
+
+- **Message**
+  - `get`
+  - `search`
+  - `updateFlags`
+  - `move`
+  - `copy`
+  - `delete` (adds `\Deleted`)
+  - `undelete` (removes `\Deleted`)
+  - `expunge`
+- **Thread**
+  - `getByMessage`
+- **Mailbox**
+  - `list`
+  - `status`
+
+### 2) IMAP Advanced Trigger
+New message trigger with:
+
+- modes: `auto`, `idle`, `poll`
+- output formats: `headersSnippet`, `full`, `raw`
+- attachment modes: `none`, `metadataOnly`, `binary`
+- optional post-processing: mark seen, add flags, move message
+
+---
+
+## Credentials
+
+This package **reuses n8n built-in IMAP credentials**:
+
+- credential type: `imap`
+- no custom IMAP credential is required
+
+---
+
+## Installation
+
+### Community package in n8n
+Install as a regular npm package where n8n runs:
+
+```bash
+npm install n8n-nodes-imap-advanced
+```
+
+or from a local tarball:
+
+```bash
+npm install /path/to/n8n-nodes-imap-advanced-0.1.0.tgz
+```
+
+Then restart n8n.
+
+---
+
+## Quick workflow example (thread + attachments)
+
+1. **IMAP Advanced Trigger** (`mode=auto`, `mailbox=INBOX`)
+2. **IMAP Advanced** (`resource=thread`, `operation=getByMessage`)
+3. loop over thread messages
+4. **IMAP Advanced** (`resource=message`, `operation=get`, `attachmentsMode=binary`)
+5. process content / attachments
+6. **IMAP Advanced** (`resource=message`, `operation=updateFlags` or `move`)
+
+---
+
+## Threading behavior
+
+`Thread:getByMessage` strategy:
+
+1. parse `References`
+2. fallback to `In-Reply-To`
+3. optional subject fallback (`Subject Fallback = true`)
+
+Notes:
+
+- IMAP has no universal thread API like Gmail API.
+- Header-based threading is best effort and may vary across servers/mailboxes.
+
+---
+
+## Attachments behavior
+
+For `Message:get` and Trigger output:
+
+- `none`: no attachment metadata/content
+- `metadataOnly`: metadata only (filename, mime, size)
+- `binary`: adds n8n binary fields (`attachment_0`, `attachment_1`, ... by default)
+
+Attachment filtering options:
+
+- max size (MB)
+- allowed MIME list (CSV)
+- filename regex
+
+---
+
+## Flags / tags
+
+IMAP “tags” are flags/keywords:
+
+- system flags: `\Seen`, `\Answered`, `\Flagged`, `\Deleted`, `\Draft`
+- custom keywords: e.g. `$n8n_processed`, `ai-replied`
+
+Use `Message:updateFlags` with:
+
+- `add`
+- `remove`
+- `replace`
+
+---
+
+## Move behavior
+
+`Message:move`:
+
+- uses IMAP `MOVE` capability when server supports it
+- otherwise falls back to `COPY + \Deleted + expunge` equivalent flow
+
+---
+
+## Development
+
+```bash
+npm install
+npm run build
+```
+
+---
+
+## Current limitations
+
+- `expunge` is mailbox-level in current implementation.
+- Threading is single-mailbox oriented.
+- IDLE mode includes practical polling safety to remain robust across server behaviors.
+
+---
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class ImapAdvanced implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/ImapAdvanced/ImapAdvanced.node.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImapAdvanced = void 0;
+const ImapAdvancedClient_1 = require("../shared/ImapAdvancedClient");
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+class ImapAdvanced {
+    constructor() {
+        this.description = {
+            displayName: 'IMAP Advanced',
+            name: 'imapAdvanced',
+            icon: 'file:imap.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Generic IMAP operations with threading and attachments',
+            defaults: { name: 'IMAP Advanced' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [{ name: 'imap', required: true }],
+            properties: [
+                { displayName: 'Resource', name: 'resource', type: 'options', default: 'message', options: [
+                        { name: 'Message', value: 'message' },
+                        { name: 'Thread', value: 'thread' },
+                        { name: 'Mailbox', value: 'mailbox' },
+                    ] },
+                { displayName: 'Operation', name: 'operation', type: 'options', default: 'get', displayOptions: { show: { resource: ['message'] } }, options: [
+                        { name: 'Get', value: 'get' },
+                        { name: 'Search', value: 'search' },
+                        { name: 'Update Flags', value: 'updateFlags' },
+                        { name: 'Move', value: 'move' },
+                        { name: 'Copy', value: 'copy' },
+                        { name: 'Delete', value: 'delete' },
+                        { name: 'Undelete', value: 'undelete' },
+                        { name: 'Expunge', value: 'expunge' },
+                    ] },
+                { displayName: 'Operation', name: 'operation', type: 'options', default: 'getByMessage', displayOptions: { show: { resource: ['thread'] } }, options: [
+                        { name: 'Get by Message', value: 'getByMessage' },
+                    ] },
+                { displayName: 'Operation', name: 'operation', type: 'options', default: 'list', displayOptions: { show: { resource: ['mailbox'] } }, options: [
+                        { name: 'List', value: 'list' },
+                        { name: 'Status', value: 'status' },
+                    ] },
+                { displayName: 'Mailbox', name: 'mailbox', type: 'string', default: 'INBOX' },
+                { displayName: 'Identifier Type', name: 'identifierType', type: 'options', default: 'uid', displayOptions: { show: { resource: ['message', 'thread'], operation: ['get', 'getByMessage'] } }, options: [
+                        { name: 'UID', value: 'uid' },
+                        { name: 'Message-ID', value: 'messageId' },
+                    ] },
+                { displayName: 'UID', name: 'uid', type: 'number', default: 0, required: true, displayOptions: { show: { resource: ['message', 'thread'], operation: ['get', 'getByMessage'], identifierType: ['uid'] } } },
+                { displayName: 'Message-ID', name: 'messageId', type: 'string', default: '', required: true, displayOptions: { show: { resource: ['message', 'thread'], operation: ['get', 'getByMessage'], identifierType: ['messageId'] } } },
+                { displayName: 'Attachments Mode', name: 'attachmentsMode', type: 'options', default: 'metadataOnly', displayOptions: { show: { resource: ['message'], operation: ['get'] } }, options: [
+                        { name: 'None', value: 'none' },
+                        { name: 'Metadata Only', value: 'metadataOnly' },
+                        { name: 'Binary', value: 'binary' },
+                    ] },
+                { displayName: 'Binary Prefix', name: 'binaryPrefix', type: 'string', default: 'attachment_', displayOptions: { show: { resource: ['message'], operation: ['get'], attachmentsMode: ['binary'] } } },
+                { displayName: 'Max Attachment Size (MB)', name: 'maxAttachmentSizeMb', type: 'number', default: 25, displayOptions: { show: { resource: ['message'], operation: ['get'], attachmentsMode: ['binary', 'metadataOnly'] } } },
+                { displayName: 'Allowed MIME Types (CSV)', name: 'allowedMimeTypes', type: 'string', default: '', displayOptions: { show: { resource: ['message'], operation: ['get'], attachmentsMode: ['binary', 'metadataOnly'] } } },
+                { displayName: 'Filename Regex', name: 'filenameRegex', type: 'string', default: '', displayOptions: { show: { resource: ['message'], operation: ['get'], attachmentsMode: ['binary', 'metadataOnly'] } } },
+                { displayName: 'UID List (CSV)', name: 'uidList', type: 'string', default: '', displayOptions: { show: { resource: ['message'], operation: ['updateFlags', 'move', 'copy', 'delete', 'undelete'] } } },
+                { displayName: 'Action', name: 'flagAction', type: 'options', default: 'add', displayOptions: { show: { resource: ['message'], operation: ['updateFlags'] } }, options: [
+                        { name: 'Add', value: 'add' },
+                        { name: 'Remove', value: 'remove' },
+                        { name: 'Replace', value: 'replace' },
+                    ] },
+                { displayName: 'Flags (CSV)', name: 'flagsCsv', type: 'string', default: '\\Seen', displayOptions: { show: { resource: ['message'], operation: ['updateFlags'] } } },
+                { displayName: 'Target Mailbox', name: 'targetMailbox', type: 'string', default: '', displayOptions: { show: { resource: ['message'], operation: ['move', 'copy'] } } },
+                { displayName: 'Raw Search JSON', name: 'searchJson', type: 'json', default: '{"seen": false}', displayOptions: { show: { resource: ['message'], operation: ['search'] } } },
+                { displayName: 'Limit', name: 'limit', type: 'number', default: 100, displayOptions: { show: { resource: ['message'], operation: ['search'] } } },
+                { displayName: 'Subject Fallback', name: 'subjectFallback', type: 'boolean', default: false, displayOptions: { show: { resource: ['thread'], operation: ['getByMessage'] } } },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const output = [];
+        for (let i = 0; i < items.length; i++) {
+            const creds = await this.getCredentials('imap');
+            const client = new ImapAdvancedClient_1.ImapAdvancedClient(creds);
+            try {
+                await client.connect();
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                const mailbox = this.getNodeParameter('mailbox', i);
+                if (resource === 'mailbox' && operation === 'list') {
+                    output.push({ json: { mailboxes: await client.listMailboxes() } });
+                    continue;
+                }
+                if (resource === 'mailbox' && operation === 'status') {
+                    output.push({ json: { status: await client.mailboxStatus(mailbox) } });
+                    continue;
+                }
+                if (resource === 'message' && operation === 'get') {
+                    const identifierType = this.getNodeParameter('identifierType', i);
+                    let uid = Number(this.getNodeParameter('uid', i, 0));
+                    if (identifierType === 'messageId') {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        await client.openMailbox(mailbox);
+                        const found = await client.search({ header: ['message-id', messageId] });
+                        const foundList = Array.isArray(found) ? found : [];
+                        uid = Number(foundList[0] || 0);
+                    }
+                    if (!uid)
+                        throw new Error('Message not found');
+                    const attachmentsMode = this.getNodeParameter('attachmentsMode', i);
+                    const binaryPrefix = this.getNodeParameter('binaryPrefix', i, 'attachment_');
+                    const maxAttachmentSizeMb = this.getNodeParameter('maxAttachmentSizeMb', i, 25);
+                    const allowedMimeTypes = this.getNodeParameter('allowedMimeTypes', i, '');
+                    const filenameRegex = this.getNodeParameter('filenameRegex', i, '');
+                    const enriched = await (0, ImapAdvancedClient_1.enrichMessage)(this, i, client, mailbox, uid, true, attachmentsMode, binaryPrefix, { maxAttachmentSizeMb, allowedMimeTypes, filenameRegex });
+                    output.push(enriched);
+                    continue;
+                }
+                if (resource === 'message' && operation === 'search') {
+                    const searchJson = this.getNodeParameter('searchJson', i, {});
+                    const limit = this.getNodeParameter('limit', i, 100);
+                    await client.openMailbox(mailbox);
+                    const uids = await client.search(searchJson);
+                    const uidList = Array.isArray(uids) ? uids : [];
+                    output.push({ json: { uids: uidList.slice(0, limit), total: uidList.length } });
+                    continue;
+                }
+                if (resource === 'message' && ['updateFlags', 'move', 'copy', 'delete', 'undelete'].includes(operation)) {
+                    const uidList = (0, ImapAdvancedClient_1.parseUidList)(String(this.getNodeParameter('uidList', i, '')));
+                    if (!uidList.length)
+                        throw new Error('uidList is required');
+                    if (operation === 'updateFlags') {
+                        const flagAction = this.getNodeParameter('flagAction', i);
+                        const flags = String(this.getNodeParameter('flagsCsv', i, ''))
+                            .split(',')
+                            .map((f) => f.trim())
+                            .filter(Boolean);
+                        output.push({ json: await client.updateFlags(uidList, mailbox, flagAction, flags) });
+                        continue;
+                    }
+                    if (operation === 'move') {
+                        const targetMailbox = this.getNodeParameter('targetMailbox', i);
+                        output.push({ json: await client.move(uidList, mailbox, targetMailbox) });
+                        continue;
+                    }
+                    if (operation === 'copy') {
+                        const targetMailbox = this.getNodeParameter('targetMailbox', i);
+                        output.push({ json: await client.copy(uidList, mailbox, targetMailbox) });
+                        continue;
+                    }
+                    if (operation === 'delete') {
+                        output.push({ json: await client.updateFlags(uidList, mailbox, 'add', ['\\Deleted']) });
+                        continue;
+                    }
+                    if (operation === 'undelete') {
+                        output.push({ json: await client.updateFlags(uidList, mailbox, 'remove', ['\\Deleted']) });
+                        continue;
+                    }
+                }
+                if (resource === 'message' && operation === 'expunge') {
+                    output.push({ json: await client.expunge(mailbox) });
+                    continue;
+                }
+                if (resource === 'thread' && operation === 'getByMessage') {
+                    const identifierType = this.getNodeParameter('identifierType', i);
+                    const subjectFallback = this.getNodeParameter('subjectFallback', i, false);
+                    let uid = Number(this.getNodeParameter('uid', i, 0));
+                    if (identifierType === 'messageId') {
+                        const messageId = this.getNodeParameter('messageId', i);
+                        await client.openMailbox(mailbox);
+                        const found = await client.search({ header: ['message-id', messageId] });
+                        const foundList = Array.isArray(found) ? found : [];
+                        uid = Number(foundList[0] || 0);
+                    }
+                    if (!uid)
+                        throw new Error('Base message not found');
+                    const base = await (0, ImapAdvancedClient_1.enrichMessage)(this, i, client, mailbox, uid, true, 'none', 'attachment_', {});
+                    const refs = (0, ImapAdvancedClient_1.parseReferences)(base.json.headers);
+                    const uids = new Set([uid]);
+                    for (const ref of refs) {
+                        const found = await client.search({ header: ['message-id', ref] });
+                        for (const u of (Array.isArray(found) ? found : []))
+                            uids.add(Number(u));
+                    }
+                    if (subjectFallback && refs.length <= 1) {
+                        const subj = String(base.json.subject || '').replace(/^(re|fwd):\s*/i, '').trim();
+                        if (subj) {
+                            const found = await client.search({ subject: subj });
+                            for (const u of (Array.isArray(found) ? found : []))
+                                uids.add(Number(u));
+                        }
+                    }
+                    const messages = await client.fetchByUids(Array.from(uids).filter(Boolean), mailbox);
+                    const normalized = messages
+                        .map((m) => { var _a, _b, _c; return ({ uid: m.uid, subject: ((_a = m.envelope) === null || _a === void 0 ? void 0 : _a.subject) || '', date: ((_c = (_b = m.internalDate) === null || _b === void 0 ? void 0 : _b.toISOString) === null || _c === void 0 ? void 0 : _c.call(_b)) || null, flags: Array.from(m.flags || []) }); })
+                        .sort((a, b) => String(a.date || '').localeCompare(String(b.date || '')));
+                    output.push({ json: { messageUid: uid, references: refs, messages: normalized } });
+                    continue;
+                }
+                throw new Error(`Unsupported combination ${resource}/${operation}`);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    output.push({ json: { error: error.message }, pairedItem: i });
+                    continue;
+                }
+                throw error;
+            }
+            finally {
+                await client.logout();
+            }
+        }
+        return [output];
+    }
+}
+exports.ImapAdvanced = ImapAdvanced;

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

@@ -0,0 +1,5 @@
+import type { INodeType, INodeTypeDescription, ITriggerFunctions, ITriggerResponse } from 'n8n-workflow';
+export declare class ImapAdvancedTrigger implements INodeType {
+    description: INodeTypeDescription;
+    trigger(this: ITriggerFunctions): Promise<ITriggerResponse>;
+}

package/dist/nodes/ImapAdvancedTrigger/ImapAdvancedTrigger.node.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImapAdvancedTrigger = void 0;
+const ImapAdvancedClient_1 = require("../shared/ImapAdvancedClient");
+class ImapAdvancedTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'IMAP Advanced Trigger',
+            name: 'imapAdvancedTrigger',
+            icon: 'file:imap.svg',
+            group: ['trigger'],
+            version: 1,
+            description: 'Trigger for new emails with IMAP IDLE/poll modes',
+            defaults: { name: 'IMAP Advanced Trigger' },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [{ name: 'imap', required: true }],
+            properties: [
+                { displayName: 'Mailbox', name: 'mailbox', type: 'string', default: 'INBOX' },
+                { displayName: 'Mode', name: 'mode', type: 'options', default: 'auto', options: [
+                        { name: 'Auto', value: 'auto' },
+                        { name: 'IDLE', value: 'idle' },
+                        { name: 'Polling', value: 'poll' },
+                    ] },
+                { displayName: 'Poll Interval (seconds)', name: 'pollInterval', type: 'number', default: 60, displayOptions: { show: { mode: ['poll'] } } },
+                { displayName: 'Output Format', name: 'outputFormat', type: 'options', default: 'headersSnippet', options: [
+                        { name: 'Headers + Snippet', value: 'headersSnippet' },
+                        { name: 'Full', value: 'full' },
+                        { name: 'Raw MIME', value: 'raw' },
+                    ] },
+                { displayName: 'Attachments', name: 'attachmentsMode', type: 'options', default: 'none', options: [
+                        { name: 'None', value: 'none' },
+                        { name: 'Metadata Only', value: 'metadataOnly' },
+                        { name: 'Binary', value: 'binary' },
+                    ] },
+                { displayName: 'Binary Prefix', name: 'binaryPrefix', type: 'string', default: 'attachment_', displayOptions: { show: { attachmentsMode: ['binary'] } } },
+                { displayName: 'Mark as Seen', name: 'markSeen', type: 'boolean', default: false },
+                { displayName: 'Add Flags (CSV)', name: 'addFlagsCsv', type: 'string', default: '' },
+                { displayName: 'Move To Mailbox', name: 'moveToMailbox', type: 'string', default: '' },
+                { displayName: 'Max Attachment Size (MB)', name: 'maxAttachmentSizeMb', type: 'number', default: 25, displayOptions: { show: { attachmentsMode: ['binary', 'metadataOnly'] } } },
+                { displayName: 'Allowed MIME Types (CSV)', name: 'allowedMimeTypes', type: 'string', default: '', displayOptions: { show: { attachmentsMode: ['binary', 'metadataOnly'] } } },
+                { displayName: 'Filename Regex', name: 'filenameRegex', type: 'string', default: '', displayOptions: { show: { attachmentsMode: ['binary', 'metadataOnly'] } } },
+            ],
+        };
+    }
+    async trigger() {
+        const creds = await this.getCredentials('imap');
+        const mailbox = this.getNodeParameter('mailbox');
+        const mode = this.getNodeParameter('mode');
+        const pollInterval = Number(this.getNodeParameter('pollInterval', 60));
+        const outputFormat = this.getNodeParameter('outputFormat');
+        const attachmentsMode = this.getNodeParameter('attachmentsMode');
+        const binaryPrefix = this.getNodeParameter('binaryPrefix', 'attachment_');
+        const markSeen = this.getNodeParameter('markSeen', false);
+        const addFlagsCsv = this.getNodeParameter('addFlagsCsv', '');
+        const moveToMailbox = this.getNodeParameter('moveToMailbox', '');
+        const maxAttachmentSizeMb = this.getNodeParameter('maxAttachmentSizeMb', 25);
+        const allowedMimeTypes = this.getNodeParameter('allowedMimeTypes', '');
+        const filenameRegex = this.getNodeParameter('filenameRegex', '');
+        const staticData = this.getWorkflowStaticData('node');
+        let running = false;
+        let timer = null;
+        let idleClient = null;
+        const emitForUid = async (uid) => {
+            var _a;
+            const emitClient = new ImapAdvancedClient_1.ImapAdvancedClient(creds);
+            try {
+                await emitClient.connect();
+                const includeRaw = outputFormat === 'raw' || outputFormat === 'full' || attachmentsMode !== 'none';
+                const enriched = await (0, ImapAdvancedClient_1.enrichMessage)(this, 0, emitClient, mailbox, uid, includeRaw, attachmentsMode, binaryPrefix, { maxAttachmentSizeMb, allowedMimeTypes, filenameRegex });
+                if (outputFormat === 'headersSnippet') {
+                    enriched.json.body = {
+                        snippet: String(((_a = enriched.json.body) === null || _a === void 0 ? void 0 : _a.text) || '').slice(0, 500),
+                    };
+                }
+                if (outputFormat === 'raw') {
+                    enriched.json.body = {};
+                }
+                const updates = [];
+                if (markSeen)
+                    updates.push('\\Seen');
+                for (const f of addFlagsCsv.split(',').map((v) => v.trim()).filter(Boolean))
+                    updates.push(f);
+                if (updates.length)
+                    await emitClient.updateFlags([uid], mailbox, 'add', updates);
+                if (moveToMailbox)
+                    await emitClient.move([uid], mailbox, moveToMailbox);
+                const executionData = { json: enriched.json };
+                if (enriched.binary)
+                    executionData.binary = enriched.binary;
+                this.emit([[executionData]]);
+            }
+            catch (error) {
+                this.logger.error(`IMAP Advanced Trigger emit failed: ${error.message}`);
+            }
+            finally {
+                await emitClient.logout();
+            }
+        };
+        const pollFn = async () => {
+            if (running)
+                return;
+            running = true;
+            try {
+                const pollClient = new ImapAdvancedClient_1.ImapAdvancedClient(creds);
+                await pollClient.connect();
+                await pollClient.openMailbox(mailbox);
+                const status = await pollClient.mailboxStatus(mailbox);
+                const lastUid = Number(staticData.lastUid || 0);
+                const maxUid = Number(status.uidNext || 0) - 1;
+                if (maxUid > lastUid) {
+                    for (let uid = Math.max(lastUid + 1, 1); uid <= maxUid; uid++) {
+                        await emitForUid(uid);
+                    }
+                    staticData.lastUid = maxUid;
+                }
+                else if (!lastUid && maxUid > 0) {
+                    staticData.lastUid = maxUid;
+                }
+                await pollClient.logout();
+            }
+            catch (error) {
+                this.logger.error(`IMAP Advanced Trigger poll failed: ${error.message}`);
+            }
+            finally {
+                running = false;
+            }
+        };
+        const setupIdle = async () => {
+            idleClient = new ImapAdvancedClient_1.ImapAdvancedClient(creds);
+            await idleClient.connect();
+            await idleClient.openMailbox(mailbox);
+            const baseStatus = await idleClient.mailboxStatus(mailbox);
+            if (!staticData.lastUid && Number(baseStatus.uidNext || 0) > 1)
+                staticData.lastUid = Number(baseStatus.uidNext) - 1;
+            idleClient.rawClient.on('exists', async () => {
+                await pollFn();
+            });
+            timer = setInterval(async () => pollFn(), 5 * 60 * 1000);
+        };
+        const initialClient = new ImapAdvancedClient_1.ImapAdvancedClient(creds);
+        await initialClient.connect();
+        const capabilities = initialClient.rawClient.capabilities || new Set();
+        await initialClient.logout();
+        const useIdle = mode === 'idle' || (mode === 'auto' && capabilities.has('IDLE'));
+        if (useIdle) {
+            await setupIdle();
+            await pollFn();
+        }
+        else {
+            await pollFn();
+            timer = setInterval(async () => pollFn(), Math.max(10, pollInterval) * 1000);
+        }
+        return {
+            closeFunction: async () => {
+                if (timer)
+                    clearInterval(timer);
+                if (idleClient)
+                    await idleClient.logout();
+            },
+        };
+    }
+}
+exports.ImapAdvancedTrigger = ImapAdvancedTrigger;

package/dist/nodes/shared/ImapAdvancedClient.d.ts

@@ -0,0 +1,45 @@
+import { ImapFlow } from 'imapflow';
+import type { IBinaryKeyData, IExecuteFunctions, IDataObject } from 'n8n-workflow';
+export type AttachmentMode = 'none' | 'metadataOnly' | 'binary';
+type AttachmentFilter = {
+    maxAttachmentSizeMb?: number;
+    allowedMimeTypes?: string;
+    filenameRegex?: string;
+};
+export declare class ImapAdvancedClient {
+    private readonly credentials;
+    private client;
+    constructor(credentials: IDataObject);
+    connect(): Promise<void>;
+    logout(): Promise<void>;
+    get rawClient(): ImapFlow;
+    openMailbox(mailbox: string): Promise<void>;
+    listMailboxes(): Promise<IDataObject[]>;
+    mailboxStatus(mailbox: string): Promise<import("imapflow").StatusObject>;
+    search(criteria: Record<string, unknown>): Promise<false | number[]>;
+    fetchOneByUid(uid: number, mailbox: string, includeRaw?: boolean): Promise<false | import("imapflow").FetchMessageObject>;
+    fetchByUids(uids: number[], mailbox: string): Promise<any[]>;
+    move(uids: number[], sourceMailbox: string, targetMailbox: string): Promise<{
+        method: string;
+        moved: number;
+    }>;
+    copy(uids: number[], sourceMailbox: string, targetMailbox: string): Promise<{
+        copied: number;
+    }>;
+    updateFlags(uids: number[], mailbox: string, action: 'add' | 'remove' | 'replace', flags: string[]): Promise<{
+        updated: number;
+        action: "add" | "remove" | "replace";
+        flags: string[];
+    }>;
+    expunge(mailbox: string): Promise<{
+        expunged: boolean;
+    }>;
+}
+export declare function normalizeAddresses(input: any): IDataObject[];
+export declare function parseReferences(headers: Record<string, unknown>): string[];
+export declare function parseUidList(input: string): number[];
+export declare function enrichMessage(ctx: IExecuteFunctions, itemIndex: number, client: ImapAdvancedClient, mailbox: string, uid: number, includeRaw: boolean, attachmentsMode: AttachmentMode, binaryPrefix: string, filters: AttachmentFilter): Promise<{
+    json: IDataObject;
+    binary?: IBinaryKeyData;
+}>;
+export {};

package/dist/nodes/shared/ImapAdvancedClient.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImapAdvancedClient = void 0;
+exports.normalizeAddresses = normalizeAddresses;
+exports.parseReferences = parseReferences;
+exports.parseUidList = parseUidList;
+exports.enrichMessage = enrichMessage;
+const imapflow_1 = require("imapflow");
+const mailparser_1 = require("mailparser");
+class ImapAdvancedClient {
+    constructor(credentials) {
+        var _a, _b;
+        this.credentials = credentials;
+        this.client = new imapflow_1.ImapFlow({
+            host: String(credentials.host || ''),
+            port: Number(credentials.port || 993),
+            secure: Boolean((_a = credentials.secure) !== null && _a !== void 0 ? _a : true),
+            auth: {
+                user: String(credentials.user || ''),
+                pass: String(credentials.password || ''),
+            },
+            tls: {
+                rejectUnauthorized: !Boolean((_b = credentials.allowUnauthorizedCerts) !== null && _b !== void 0 ? _b : false),
+            },
+        });
+    }
+    async connect() {
+        if (!this.client.usable)
+            await this.client.connect();
+    }
+    async logout() {
+        if (this.client.usable)
+            await this.client.logout();
+    }
+    get rawClient() {
+        return this.client;
+    }
+    async openMailbox(mailbox) {
+        await this.client.mailboxOpen(mailbox || 'INBOX');
+    }
+    async listMailboxes() {
+        const out = [];
+        const boxes = await this.client.list();
+        for (const box of boxes) {
+            out.push({
+                path: box.path,
+                delimiter: box.delimiter,
+                specialUse: box.specialUse,
+                listed: box.listed,
+                subscribed: box.subscribed,
+            });
+        }
+        return out;
+    }
+    async mailboxStatus(mailbox) {
+        return this.client.status(mailbox || 'INBOX', { messages: true, unseen: true, uidNext: true, uidValidity: true, highestModseq: true });
+    }
+    async search(criteria) {
+        const query = criteria;
+        return this.client.search(query, { uid: true });
+    }
+    async fetchOneByUid(uid, mailbox, includeRaw = false) {
+        await this.openMailbox(mailbox);
+        return this.client.fetchOne(String(uid), {
+            envelope: true,
+            flags: true,
+            internalDate: true,
+            source: includeRaw,
+            bodyStructure: true,
+            headers: true,
+        }, { uid: true });
+    }
+    async fetchByUids(uids, mailbox) {
+        await this.openMailbox(mailbox);
+        const out = [];
+        if (!uids.length)
+            return out;
+        for await (const msg of this.client.fetch(uids, {
+            envelope: true,
+            flags: true,
+            internalDate: true,
+            headers: true,
+        }, { uid: true })) {
+            out.push(msg);
+        }
+        return out;
+    }
+    async move(uids, sourceMailbox, targetMailbox) {
+        await this.openMailbox(sourceMailbox);
+        const capabilities = this.client.capabilities || new Set();
+        if (capabilities.has('MOVE')) {
+            await this.client.messageMove(uids, targetMailbox, { uid: true });
+            return { method: 'move', moved: uids.length };
+        }
+        await this.client.messageCopy(uids, targetMailbox, { uid: true });
+        await this.client.messageFlagsAdd(uids, ['\\Deleted'], { uid: true });
+        await this.client.messageDelete(uids, { uid: true });
+        return { method: 'copy-store-expunge', moved: uids.length };
+    }
+    async copy(uids, sourceMailbox, targetMailbox) {
+        await this.openMailbox(sourceMailbox);
+        await this.client.messageCopy(uids, targetMailbox, { uid: true });
+        return { copied: uids.length };
+    }
+    async updateFlags(uids, mailbox, action, flags) {
+        await this.openMailbox(mailbox);
+        if (action === 'add')
+            await this.client.messageFlagsAdd(uids, flags, { uid: true });
+        if (action === 'remove')
+            await this.client.messageFlagsRemove(uids, flags, { uid: true });
+        if (action === 'replace')
+            await this.client.messageFlagsSet(uids, flags, { uid: true });
+        return { updated: uids.length, action, flags };
+    }
+    async expunge(mailbox) {
+        await this.openMailbox(mailbox);
+        await this.client.messageDelete('1:*');
+        return { expunged: true };
+    }
+}
+exports.ImapAdvancedClient = ImapAdvancedClient;
+function normalizeAddresses(input) {
+    if (!Array.isArray(input))
+        return [];
+    const out = [];
+    for (const group of input) {
+        const list = Array.isArray(group === null || group === void 0 ? void 0 : group.addresses) ? group.addresses : [];
+        for (const a of list) {
+            out.push({ name: a.name || '', address: a.address || '' });
+        }
+    }
+    return out;
+}
+function parseReferences(headers) {
+    const candidates = [headers.references, headers['in-reply-to'], headers['message-id']]
+        .filter(Boolean)
+        .map((v) => String(v));
+    const set = new Set();
+    for (const line of candidates) {
+        const matches = line.match(/<[^>]+>/g) || [];
+        for (const m of matches)
+            set.add(m.trim());
+    }
+    return Array.from(set);
+}
+function parseUidList(input) {
+    return input
+        .split(',')
+        .map((s) => Number(s.trim()))
+        .filter((n) => Number.isFinite(n) && n > 0);
+}
+async function enrichMessage(ctx, itemIndex, client, mailbox, uid, includeRaw, attachmentsMode, binaryPrefix, filters) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const data = await client.fetchOneByUid(uid, mailbox, includeRaw || attachmentsMode !== 'none');
+    if (!data)
+        throw new Error(`Message not found for UID ${uid}`);
+    const headersObj = Object.fromEntries(((_b = (_a = (data.headers || new Map())).entries) === null || _b === void 0 ? void 0 : _b.call(_a)) || []);
+    const sourceBuffer = data.source ? Buffer.from(data.source) : undefined;
+    const parsed = sourceBuffer ? await (0, mailparser_1.simpleParser)(sourceBuffer) : null;
+    const json = {
+        uid: data.uid,
+        seq: data.seq,
+        messageId: (parsed === null || parsed === void 0 ? void 0 : parsed.messageId) || String(headersObj['message-id'] || ''),
+        subject: (parsed === null || parsed === void 0 ? void 0 : parsed.subject) || ((_c = data.envelope) === null || _c === void 0 ? void 0 : _c.subject) || '',
+        date: ((_e = (_d = parsed === null || parsed === void 0 ? void 0 : parsed.date) === null || _d === void 0 ? void 0 : _d.toISOString) === null || _e === void 0 ? void 0 : _e.call(_d)) || ((_g = (_f = data.internalDate) === null || _f === void 0 ? void 0 : _f.toISOString) === null || _g === void 0 ? void 0 : _g.call(_f)) || null,
+        from: normalizeAddresses(((_h = data.envelope) === null || _h === void 0 ? void 0 : _h.from) || []),
+        to: normalizeAddresses(((_j = data.envelope) === null || _j === void 0 ? void 0 : _j.to) || []),
+        cc: normalizeAddresses(((_k = data.envelope) === null || _k === void 0 ? void 0 : _k.cc) || []),
+        flags: Array.from(data.flags || []),
+        headers: headersObj,
+        thread: {
+            references: parseReferences(headersObj),
+            inReplyTo: String(headersObj['in-reply-to'] || ''),
+        },
+        body: {
+            text: (parsed === null || parsed === void 0 ? void 0 : parsed.text) || '',
+            html: (parsed === null || parsed === void 0 ? void 0 : parsed.html) ? String(parsed.html) : '',
+        },
+        attachments: [],
+    };
+    if (attachmentsMode === 'none')
+        return { json };
+    const binary = {};
+    const attachmentList = (parsed === null || parsed === void 0 ? void 0 : parsed.attachments) || [];
+    const maxBytes = Number(filters.maxAttachmentSizeMb || 25) * 1024 * 1024;
+    const allowedMime = String(filters.allowedMimeTypes || '')
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter(Boolean);
+    const filenameRegex = String(filters.filenameRegex || '').trim();
+    const matcher = filenameRegex ? new RegExp(filenameRegex) : null;
+    for (let i = 0; i < attachmentList.length; i++) {
+        const att = attachmentList[i];
+        const mimeType = (att.contentType || '').toLowerCase();
+        const filename = att.filename || `attachment_${i}`;
+        const size = Number(att.size || ((_l = att.content) === null || _l === void 0 ? void 0 : _l.length) || 0);
+        if (size > maxBytes)
+            continue;
+        if (allowedMime.length && !allowedMime.includes(mimeType))
+            continue;
+        if (matcher && !matcher.test(filename))
+            continue;
+        const meta = {
+            filename,
+            contentType: att.contentType || 'application/octet-stream',
+            size,
+        };
+        if (attachmentsMode === 'binary' && att.content) {
+            const key = `${binaryPrefix || 'attachment_'}${Object.keys(binary).length}`;
+            const prepared = await ctx.helpers.prepareBinaryData(Buffer.from(att.content), filename, att.contentType || 'application/octet-stream');
+            binary[key] = prepared;
+            meta.binaryProperty = key;
+        }
+        json.attachments.push(meta);
+    }
+    return Object.keys(binary).length ? { json, binary } : { json };
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "n8n-nodes-imap-advanced",
+  "version": "0.1.1",
+  "description": "n8n community nodes for advanced generic IMAP workflows",
+  "license": "MIT",
+  "author": "Maxime Olivier",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "imap",
+    "mail",
+    "email"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "imapflow": "^1.2.10",
+    "mailparser": "^3.9.3"
+  },
+  "devDependencies": {
+    "@types/mailparser": "^3.4.6",
+    "@types/node": "^20.17.19",
+    "n8n-workflow": "^1.82.0",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "n8n-workflow": ">=1.82.0"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [],
+    "nodes": [
+      "dist/nodes/ImapAdvanced/ImapAdvanced.node.js",
+      "dist/nodes/ImapAdvancedTrigger/ImapAdvancedTrigger.node.js"
+    ]
+  },
+  "homepage": "https://github.com/ClawBow/n8n-nodes-imap-advanced",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ClawBow/n8n-nodes-imap-advanced.git"
+  }
+}