@jep182/n8n-nodes-whatsthat 0.4.2 → 0.5.0

package/README.md

@@ -1,124 +1,198 @@
 # @jep182/n8n-nodes-whatsthat
 
-WhatsThat is an n8n community package for sending WhatsApp messages, with multiple sessions.
+WhatsThat lets you connect one or more WhatsApp numbers inside n8n, link chats or groups with simple names, send messages, and react to incoming events.
 
-It lets you:
+You will mainly use:
 
-- manage multiple sessions and numbers
-- connect with pairing code or QR
-- discover chats and groups
-- link chats/groups to friendly aliases
-- send text, media, documents, reactions, contacts, locations, and polls
-- receive inbound events through a trigger node
+- `WhatsThat`
+- `WhatsThat Trigger`
 
-## Included Nodes
+You also need one credential:
 
-### `WhatsThat Session`
+- `WhatsThat Runtime`
 
-Use this node to:
+## Before You Start
 
-- create a session
-- connect a session
-- list sessions
-- inspect session status
-- disconnect a session
-- remove a session
+Create `WhatsThat Runtime` credentials and choose a persistent storage path, for example:
 
-When pairing is available, the node returns:
+```text
+/home/node/.n8n/whatsthat
+```
 
-- `pairingCode`
-- `qrCodeUrl`
-- `qr`
-- `qrDataUrl`
+This folder is used to store session files and local metadata.
 
-### `WhatsThat Targets`
+## How To Connect Your Number
 
-Use this node to:
+1. Add a `WhatsThat` node.
+2. Set `Resource` to `Session`.
+3. Set `Operation` to `Connect Session`.
+4. Fill in:
+   - `Session Name`: a stable internal name like `main-phone`
+   - `Display Name`: a friendly label like `Luca phone`
+   - `WhatsApp Number`: optional, only if you want a pairing code instead of relying only on QR
+5. Run the node.
+6. In the output, open `qrCodeUrl`.
 
-- list discovered chats and groups
-- list linked aliases
-- link a target to an alias
-- unlink an alias
+Open `qrCodeUrl` as the standard and recommended way to connect the number.
 
-### `WhatsThat Message`
+Important:
 
-Use this node to send:
+- open `qrCodeUrl` whenever possible
+- do not rely on `pairingCode`
+- `pairingCode` is not stable and may fail or stop working depending on the session state and device behavior
+- `qrDataUrl` is available only if you specifically need the raw embedded QR image data
 
-- text
-- image
-- video
-- audio
-- document
-- reaction
-- location
-- contact
-- poll
+Example:
 
-For images and videos, the node can decide internally whether to send them as:
+```text
+Session Name: main-phone
+Display Name: Luca phone
+WhatsApp Number: 393331234567
+```
 
-- native media
-- file/document attachment
+## How To Wait Until The Number Is Fully Connected
 
-### `WhatsThat Trigger`
+After `Connect Session`, add another `WhatsThat` node:
 
-Use this node to listen for:
+1. Set `Resource` to `Session`
+2. Set `Operation` to `Wait Until Connect`
+3. Use the same `Session Name`
+4. Choose how many seconds to wait in `Timeout Seconds`
 
-- incoming messages
-- your own sent messages
-- session pairing events
-- session connected/disconnected events
-- group updates
+This second node waits for the already-started session to become fully connected.
+
+## How To Link A Group Or Chat Manually
+
+1. Add a `WhatsThat` node
+2. Set `Resource` to `Linked Chat`
+3. Start with `Operation = List Discovered Chats`
+4. Pick the chat or group you want to use
+5. Change to `Operation = Link Chat`
+6. Fill in:
+   - `Session Name`
+   - `Chat JID`
+   - `Linked Chat`: the simple name you want to use later, for example `support` or `team`
 
-## How It Works
+Example:
+
+```text
+Linked Chat: support
+```
 
-WhatsThat embeds Baileys directly in n8n.
+After that, you can send messages by choosing that linked chat instead of writing the raw JID every time.
 
-- session auth files are stored on disk
-- session metadata and linked targets are stored as local JSON files under the runtime storage path
+## How To Link A Group Or Chat From WhatsApp
 
-## Quick Start
+Use `WhatsThat Trigger`.
 
-1. Create `WhatsThat Runtime` credentials.
-2. Set a storage path, for example:
+1. Add a `WhatsThat Trigger` node
+2. Select the same `Session Name`
+3. Set `Event` to `Link Chat Command`
+4. Leave the default command or change it
+
+By default, users can send a message like:
 
 ```text
-/home/node/.n8n/whatsthat
+/link-whatsthat support
 ```
 
-3. Add `WhatsThat Session`.
-4. Choose `Ensure Session`, then provide:
-   - `Session ID (Internal)`: a stable unique ID such as `main-phone`
-   - `Label (Visible Name)`: a human-readable name such as `Luca personal phone`
-   - optional `Phone Number For Pairing`: full number with country code, digits only, without `00` or `+`
-5. Set `Return When` to `Pairing Is Ready Or Connected` for first-time pairing.
-6. Use the returned `pairingCode`, `qrCodeUrl`, or `qrDataUrl` to connect the device.
-7. Use `WhatsThat Targets` to discover and link chats/groups.
-8. Use `WhatsThat Message` to send messages by alias or raw JID.
+If that message is sent inside a group or chat, WhatsThat links that conversation with alias `support`.
 
-Example workflow:
+This is useful when you want users to self-register a group without opening n8n.
 
-- [`examples/register-number.workflow.json`](./examples/register-number.workflow.json)
+## How To Send A Message To A Linked Chat
 
-## Media Delivery
+1. Add a `WhatsThat` node
+2. Set `Resource` to `Send Message`
+3. Set `Session Name`
+4. Set `Send Message To` to `Linked Chat`
+5. Choose a linked chat from the dropdown
+6. Choose `Message Type`
+7. Write the message
 
-For `Image` and `Video` messages:
+Example:
 
-- `Native Media` sends them as normal media with preview
-- `As File` sends them as a document/file attachment
+```text
+Send Message To: Linked Chat
+Linked Chat: support
+Message Type: Text
+Message: Hello from n8n
+```
 
-## Notes
+## How To Send A Message To A Number
 
-- This package runs an active WebSocket client inside n8n.
-- For production, use persistent storage for the auth directory.
-- Use one n8n instance as the runtime owner for these sessions.
+1. Add a `WhatsThat` node
+2. Set `Resource` to `Send Message`
+3. Set `Send Message To` to `WhatsApp Number`
+4. Enter the number with country code, digits only, without `00` and without `+`
 
-## Thanks
+Example:
+
+```text
+WhatsApp Number: 393331234567
+```
+
+## How To Send A Message To Yourself
+
+1. Add a `WhatsThat` node
+2. Set `Resource` to `Send Message`
+3. Set `Send Message To` to `Yourself`
 
-This project relies on [Baileys](https://github.com/WhiskeySockets/Baileys), the open-source TypeScript/Node.js library that powers the messaging client layer.
+WhatsThat uses the number already connected for that session.
 
-Please review the Baileys project, its license, and its usage notes before running it in production:
+This is useful for testing.
+
+## How To Send Media
+
+For images and videos you can choose:
+
+- `Native Media`
+- `As File`
+
+Use `Media URL` for the file you want to send.
+
+Examples:
+
+- send an image preview normally
+- send a PDF as a document
+- send a video as a file attachment
+
+## How To Receive Events
+
+Use `WhatsThat Trigger` when you want to react to:
+
+- incoming messages
+- your own sent messages
+- pairing events
+- connection events
+- group updates
+
+Common examples:
+
+- start a workflow when a message arrives
+- auto-link a chat with `/link-whatsthat support`
+- continue a workflow when a session becomes connected
+
+## Example Workflow
+
+You can import this example:
+
+- [`examples/register-number.workflow.json`](./examples/register-number.workflow.json)
+
+It shows the basic flow:
+
+1. `Connect Session`
+2. `Wait Until Connect`
+
+## Notes
+
+- Use one persistent n8n instance as the owner of these sessions
+- Keep the runtime storage path persistent
+- If n8n restarts, active in-memory sockets are restarted from the saved session files
+
+## Thanks
 
-- [Baileys repository](https://github.com/WhiskeySockets/Baileys)
+This project uses [Baileys](https://github.com/WhiskeySockets/Baileys).
 
 ## License
 

package/dist/index.d.ts

@@ -1,5 +1,3 @@
 export * from './credentials/WhatsThatRuntime.credentials';
-export * from './nodes/WhatsThatSession/WhatsThatSession.node';
-export * from './nodes/WhatsThatTargets/WhatsThatTargets.node';
-export * from './nodes/WhatsThatMessage/WhatsThatMessage.node';
+export * from './nodes/WhatsThat/WhatsThat.node';
 export * from './nodes/WhatsThatTrigger/WhatsThatTrigger.node';

package/dist/index.js

@@ -15,7 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./credentials/WhatsThatRuntime.credentials"), exports);
-__exportStar(require("./nodes/WhatsThatSession/WhatsThatSession.node"), exports);
-__exportStar(require("./nodes/WhatsThatTargets/WhatsThatTargets.node"), exports);
-__exportStar(require("./nodes/WhatsThatMessage/WhatsThatMessage.node"), exports);
+__exportStar(require("./nodes/WhatsThat/WhatsThat.node"), exports);
 __exportStar(require("./nodes/WhatsThatTrigger/WhatsThatTrigger.node"), exports);

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

@@ -0,0 +1,10 @@
+import type { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class WhatsThat implements INodeType {
+    methods: {
+        loadOptions: {
+            getLinkedAliases(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/WhatsThat/WhatsThat.node.js

@@ -0,0 +1,647 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsThat = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const access_1 = require("../../shared/access");
+const runtime_1 = require("../../shared/runtime");
+const validation_1 = require("../../shared/validation");
+function buildPayload(context, itemIndex) {
+    const messageType = context.getNodeParameter('messageType', itemIndex);
+    const sendMessageTo = context.getNodeParameter('sendMessageTo', itemIndex);
+    const deliveryMode = context.getNodeParameter('deliveryMode', itemIndex, 'native');
+    const payload = {
+        sessionId: (0, validation_1.requireSessionId)(context.getNodeParameter('sessionId', itemIndex)),
+        type: messageType,
+    };
+    if (sendMessageTo === 'linkedChat') {
+        payload.channelAlias = context.getNodeParameter('linkedAlias', itemIndex);
+    }
+    else if (sendMessageTo === 'jid') {
+        payload.jid = context.getNodeParameter('jid', itemIndex);
+    }
+    else if (sendMessageTo === 'number') {
+        payload.phoneNumber = (0, validation_1.requireWhatsappNumber)(context.getNodeParameter('phoneNumber', itemIndex));
+    }
+    else if (sendMessageTo === 'yourself') {
+        payload.sendToSelf = true;
+    }
+    payload.message = context.getNodeParameter('message', itemIndex, '');
+    payload.replyToMessageId = context.getNodeParameter('replyToMessageId', itemIndex, '');
+    if (['image', 'video', 'audio', 'document'].includes(messageType)) {
+        payload.mediaUrl = context.getNodeParameter('mediaUrl', itemIndex);
+        payload.mimetype = context.getNodeParameter('mimetype', itemIndex, '');
+        payload.fileName = context.getNodeParameter('fileName', itemIndex, '');
+    }
+    if (['image', 'video'].includes(messageType)) {
+        payload.sendAsDocument = deliveryMode === 'document';
+    }
+    if (['image', 'video', 'document'].includes(messageType)) {
+        payload.caption = context.getNodeParameter('caption', itemIndex, '');
+    }
+    if (messageType === 'reaction') {
+        payload.reactionText = context.getNodeParameter('reactionText', itemIndex, '👍');
+    }
+    if (messageType === 'location') {
+        payload.location = {
+            degreesLatitude: context.getNodeParameter('latitude', itemIndex),
+            degreesLongitude: context.getNodeParameter('longitude', itemIndex),
+            name: context.getNodeParameter('locationName', itemIndex, ''),
+            address: context.getNodeParameter('locationAddress', itemIndex, ''),
+        };
+    }
+    if (messageType === 'contact') {
+        payload.contact = {
+            displayName: context.getNodeParameter('contactName', itemIndex),
+            vcard: context.getNodeParameter('contactVcard', itemIndex),
+        };
+    }
+    if (messageType === 'poll') {
+        const raw = context.getNodeParameter('pollOptions', itemIndex);
+        payload.poll = {
+            name: context.getNodeParameter('pollName', itemIndex),
+            values: raw.split(',').map((value) => value.trim()).filter(Boolean),
+            selectableCount: context.getNodeParameter('pollSelectableCount', itemIndex, 1),
+        };
+    }
+    return payload;
+}
+function formatSessionOutput(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => formatSessionOutput(item));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const record = value;
+    if (!('sessionId' in record) || !('status' in record)) {
+        return value;
+    }
+    return {
+        qrCodeUrl: record.qrCodeUrl,
+        sessionId: record.sessionId,
+        status: record.status,
+        pairingCode: record.pairingCode,
+        qr: record.qr,
+        qrDataUrl: record.qrDataUrl,
+        phone: record.phone,
+        label: record.label,
+        phoneNumberForPairing: record.phoneNumberForPairing,
+        lastDisconnectReason: record.lastDisconnectReason,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        lastSeenAt: record.lastSeenAt,
+    };
+}
+class WhatsThat {
+    constructor() {
+        this.methods = {
+            loadOptions: {
+                async getLinkedAliases() {
+                    const access = await (0, access_1.buildAccess)(this);
+                    const sessionId = (0, validation_1.requireSessionId)(this.getNodeParameter('sessionId'));
+                    const linked = await runtime_1.registry.listLinkedTargets(access, sessionId);
+                    return linked.map((item) => ({
+                        name: `${item.alias} (${item.displayName})`,
+                        value: item.alias,
+                    }));
+                },
+            },
+        };
+        this.description = {
+            displayName: 'WhatsThat',
+            name: 'whatsThat',
+            icon: 'file:../WhatsThatSession/whatsthat.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Manage sessions, chat links, and messages for WhatsThat',
+            defaults: { name: 'WhatsThat' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [{ name: 'whatsThatRuntime', required: true }],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    default: 'session',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Session', value: 'session' },
+                        { name: 'Linked Chat', value: 'linkChat' },
+                        { name: 'Send Message', value: 'sendMessage' },
+                    ],
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'sessionOperation',
+                    type: 'options',
+                    default: 'connect',
+                    displayOptions: {
+                        show: { resource: ['session'] },
+                    },
+                    options: [
+                        { name: 'Connect Session', value: 'connect' },
+                        { name: 'Wait Until Connect', value: 'ensure' },
+                        { name: 'List Sessions', value: 'list' },
+                        { name: 'Get Session', value: 'status' },
+                        { name: 'Disconnect Session', value: 'disconnect' },
+                        { name: 'Remove Session', value: 'remove' },
+                    ],
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'linkChatOperation',
+                    type: 'options',
+                    default: 'listDiscovered',
+                    displayOptions: {
+                        show: { resource: ['linkChat'] },
+                    },
+                    options: [
+                        { name: 'List Discovered Chats', value: 'listDiscovered' },
+                        { name: 'List Linked Chats', value: 'listLinked' },
+                        { name: 'Link Chat', value: 'link' },
+                        { name: 'Unlink Chat', value: 'unlink' },
+                    ],
+                },
+                {
+                    displayName: 'Session Name',
+                    name: 'sessionId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'Required unique ID for this session. Use a stable internal value such as "main-phone" or "support-team".',
+                    displayOptions: {
+                        hide: {
+                            resource: ['session'],
+                            sessionOperation: ['list'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Display Name',
+                    name: 'label',
+                    type: 'string',
+                    default: '',
+                    description: 'Human-readable name shown in results. Example: "Luca personal phone" or "Support number".',
+                    displayOptions: {
+                        show: {
+                            resource: ['session'],
+                            sessionOperation: ['connect'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'WhatsApp Number',
+                    name: 'phoneNumberForPairing',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Full phone number with country code, digits only, without 00 or +. Example: 393331234567.',
+                    displayOptions: {
+                        show: {
+                            resource: ['session'],
+                            sessionOperation: ['connect'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Timeout Seconds',
+                    name: 'timeoutSeconds',
+                    type: 'number',
+                    default: 300,
+                    typeOptions: {
+                        minValue: 1,
+                    },
+                    description: 'Maximum time to wait before returning the latest known session status.',
+                    displayOptions: {
+                        show: {
+                            resource: ['session'],
+                            sessionOperation: ['ensure'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Chat JID',
+                    name: 'linkJid',
+                    type: 'string',
+                    default: '',
+                    description: 'The raw WhatsApp JID to link. Usually taken from List Discovered Chats.',
+                    displayOptions: {
+                        show: {
+                            resource: ['linkChat'],
+                            linkChatOperation: ['link'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Linked Chat',
+                    name: 'linkAlias',
+                    type: 'string',
+                    default: '',
+                    description: 'Friendly name you will use later when sending messages by alias.',
+                    displayOptions: {
+                        show: {
+                            resource: ['linkChat'],
+                            linkChatOperation: ['link', 'unlink'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Send Message To',
+                    name: 'sendMessageTo',
+                    type: 'options',
+                    default: 'linkedChat',
+                    description: 'Choose how to resolve the destination chat.',
+                    options: [
+                        { name: 'Linked Chat', value: 'linkedChat' },
+                        { name: 'WhatsApp Number', value: 'number' },
+                        { name: 'Raw JID', value: 'jid' },
+                        { name: 'Yourself', value: 'yourself' },
+                    ],
+                    displayOptions: {
+                        show: { resource: ['sendMessage'] },
+                    },
+                },
+                {
+                    displayName: 'Linked Chat',
+                    name: 'linkedAlias',
+                    type: 'options',
+                    default: '',
+                    description: 'Choose one of the linked chats saved for this session.',
+                    typeOptions: {
+                        loadOptionsMethod: 'getLinkedAliases',
+                    },
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            sendMessageTo: ['linkedChat'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'WhatsApp Number',
+                    name: 'phoneNumber',
+                    type: 'string',
+                    default: '',
+                    description: 'Full phone number with country code, digits only, without 00 or +. Example: 393331234567.',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            sendMessageTo: ['number'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'JID',
+                    name: 'jid',
+                    type: 'string',
+                    default: '',
+                    description: 'Raw WhatsApp JID, for example 393331234567@s.whatsapp.net or a group JID.',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            sendMessageTo: ['jid'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Yourself',
+                    name: 'yourselfNotice',
+                    type: 'notice',
+                    default: '',
+                    description: 'Send the message to the WhatsApp number already connected for this session.',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            sendMessageTo: ['yourself'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Message Type',
+                    name: 'messageType',
+                    type: 'options',
+                    default: 'text',
+                    description: 'The kind of outbound message to send.',
+                    displayOptions: {
+                        show: { resource: ['sendMessage'] },
+                    },
+                    options: [
+                        { name: 'Text', value: 'text' },
+                        { name: 'Image', value: 'image' },
+                        { name: 'Video', value: 'video' },
+                        { name: 'Audio', value: 'audio' },
+                        { name: 'Document', value: 'document' },
+                        { name: 'Reaction', value: 'reaction' },
+                        { name: 'Location', value: 'location' },
+                        { name: 'Contact', value: 'contact' },
+                        { name: 'Poll', value: 'poll' },
+                    ],
+                },
+                {
+                    displayName: 'Delivery Mode',
+                    name: 'deliveryMode',
+                    type: 'options',
+                    default: 'native',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['image', 'video'],
+                        },
+                    },
+                    options: [
+                        { name: 'Native Media', value: 'native' },
+                        { name: 'As File', value: 'document' },
+                    ],
+                },
+                {
+                    displayName: 'Message',
+                    name: 'message',
+                    type: 'string',
+                    typeOptions: { rows: 4 },
+                    default: '',
+                    description: 'Main text body for the outbound message.',
+                    displayOptions: {
+                        show: { resource: ['sendMessage'] },
+                        hide: { messageType: ['location', 'contact', 'poll'] },
+                    },
+                },
+                {
+                    displayName: 'Media URL',
+                    name: 'mediaUrl',
+                    type: 'string',
+                    default: '',
+                    description: 'Public URL or reachable file URL for the media to send.',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['image', 'video', 'audio', 'document'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Caption',
+                    name: 'caption',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['image', 'video', 'document'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Mimetype',
+                    name: 'mimetype',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['image', 'video', 'audio', 'document'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'File Name',
+                    name: 'fileName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['image', 'video', 'document'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Reply To Message ID',
+                    name: 'replyToMessageId',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Reply or react to a specific WhatsApp message ID.',
+                    displayOptions: {
+                        show: { resource: ['sendMessage'] },
+                    },
+                },
+                {
+                    displayName: 'Reaction Text',
+                    name: 'reactionText',
+                    type: 'string',
+                    default: '👍',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['reaction'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Latitude',
+                    name: 'latitude',
+                    type: 'number',
+                    default: 0,
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['location'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Longitude',
+                    name: 'longitude',
+                    type: 'number',
+                    default: 0,
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['location'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Location Name',
+                    name: 'locationName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['location'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Location Address',
+                    name: 'locationAddress',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['location'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Contact Name',
+                    name: 'contactName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['contact'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Contact VCard',
+                    name: 'contactVcard',
+                    type: 'string',
+                    typeOptions: { rows: 4 },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['contact'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Poll Name',
+                    name: 'pollName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['poll'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Poll Options',
+                    name: 'pollOptions',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['poll'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Selectable Count',
+                    name: 'pollSelectableCount',
+                    type: 'number',
+                    default: 1,
+                    displayOptions: {
+                        show: {
+                            resource: ['sendMessage'],
+                            messageType: ['poll'],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const access = await (0, access_1.buildAccess)(this);
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const resource = this.getNodeParameter('resource', itemIndex);
+                const rawSessionId = this.getNodeParameter('sessionId', itemIndex, '');
+                let json;
+                if (resource === 'session') {
+                    const operation = this.getNodeParameter('sessionOperation', itemIndex);
+                    const sessionId = operation === 'list' ? (0, validation_1.normalizeSessionId)(rawSessionId) : (0, validation_1.requireSessionId)(rawSessionId);
+                    switch (operation) {
+                        case 'connect': {
+                            const label = this.getNodeParameter('label', itemIndex, '').trim();
+                            const phoneNumberForPairing = this.getNodeParameter('phoneNumberForPairing', itemIndex, '').trim();
+                            await runtime_1.registry.ensureSession(access.paths.root, access, {
+                                sessionId,
+                                label: label || sessionId,
+                                phoneNumberForPairing,
+                            });
+                            json = await runtime_1.registry.connectSession(access.paths.root, access, sessionId);
+                            break;
+                        }
+                        case 'ensure': {
+                            const label = this.getNodeParameter('label', itemIndex, '').trim();
+                            const phoneNumberForPairing = this.getNodeParameter('phoneNumberForPairing', itemIndex, '').trim();
+                            const timeoutSeconds = this.getNodeParameter('timeoutSeconds', itemIndex, 300);
+                            json = await runtime_1.registry.ensureConnectedSession(access.paths.root, access, {
+                                sessionId,
+                                label: label || sessionId,
+                                phoneNumberForPairing,
+                            }, {
+                                waitFor: 'connected',
+                                timeoutMs: timeoutSeconds * 1000,
+                            });
+                            break;
+                        }
+                        case 'list':
+                            json = await runtime_1.registry.listSessions(access);
+                            break;
+                        case 'status':
+                            json = (await runtime_1.registry.getSession(access, sessionId)) ?? null;
+                            break;
+                        case 'disconnect':
+                            json = (await runtime_1.registry.disconnectSession(access, sessionId)) ?? null;
+                            break;
+                        case 'remove':
+                            json = { removed: await runtime_1.registry.removeSession(access, sessionId) };
+                            break;
+                        default:
+                            throw new Error(`Unsupported session operation ${operation}`);
+                    }
+                    json = formatSessionOutput(json);
+                }
+                else if (resource === 'linkChat') {
+                    const operation = this.getNodeParameter('linkChatOperation', itemIndex);
+                    const sessionId = (0, validation_1.requireSessionId)(rawSessionId);
+                    switch (operation) {
+                        case 'listDiscovered':
+                            json = await runtime_1.registry.listTargets(access, sessionId);
+                            break;
+                        case 'listLinked':
+                            json = await runtime_1.registry.listLinkedTargets(access, sessionId);
+                            break;
+                        case 'link':
+                            json = await runtime_1.registry.connectTarget(access, sessionId, this.getNodeParameter('linkAlias', itemIndex), this.getNodeParameter('linkJid', itemIndex));
+                            break;
+                        case 'unlink':
+                            json = {
+                                removed: await runtime_1.registry.unlinkTarget(access, sessionId, this.getNodeParameter('linkAlias', itemIndex)),
+                            };
+                            break;
+                        default:
+                            throw new Error(`Unsupported link chat operation ${operation}`);
+                    }
+                }
+                else if (resource === 'sendMessage') {
+                    json = await runtime_1.registry.sendMessage(access, buildPayload(this, itemIndex));
+                }
+                else {
+                    throw new Error(`Unsupported resource ${resource}`);
+                }
+                returnData.push({ json: json, pairedItem: itemIndex });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: itemIndex });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.WhatsThat = WhatsThat;

package/dist/nodes/WhatsThatSession/WhatsThatSession.node.js

@@ -23,8 +23,9 @@ class WhatsThatSession {
                     displayName: 'Operation',
                     name: 'operation',
                     type: 'options',
-                    default: 'ensure',
+                    default: 'connect',
                     options: [
+                        { name: 'Connect Session', value: 'connect' },
                         { name: 'Ensure Session', value: 'ensure' },
                         { name: 'List Sessions', value: 'list' },
                         { name: 'Get Session Status', value: 'status' },
@@ -50,7 +51,7 @@ class WhatsThatSession {
                     default: '',
                     description: 'Human-readable name shown in results. Example: "Luca personal phone" or "Support number".',
                     displayOptions: {
-                        show: { operation: ['ensure'] },
+                        show: { operation: ['connect', 'ensure'] },
                     },
                 },
                 {
@@ -60,7 +61,7 @@ class WhatsThatSession {
                     default: '',
                     description: 'Optional. Full phone number with country code, digits only, without 00 or +. Example: 393331234567.',
                     displayOptions: {
-                        show: { operation: ['ensure'] },
+                        show: { operation: ['connect', 'ensure'] },
                     },
                 },
                 {
@@ -104,6 +105,17 @@ class WhatsThatSession {
                 const sessionId = operation === 'list' ? (0, validation_1.normalizeSessionId)(rawSessionId) : (0, validation_1.requireSessionId)(rawSessionId);
                 let json;
                 switch (operation) {
+                    case 'connect': {
+                        const label = this.getNodeParameter('label', itemIndex, '').trim();
+                        const phoneNumberForPairing = this.getNodeParameter('phoneNumberForPairing', itemIndex, '').trim();
+                        await runtime_1.registry.ensureSession(access.paths.root, access, {
+                            sessionId,
+                            label: label || sessionId,
+                            phoneNumberForPairing,
+                        });
+                        json = await runtime_1.registry.connectSession(access.paths.root, access, sessionId);
+                        break;
+                    }
                     case 'ensure': {
                         const label = this.getNodeParameter('label', itemIndex, '').trim();
                         const phoneNumberForPairing = this.getNodeParameter('phoneNumberForPairing', itemIndex, '').trim();

package/dist/nodes/WhatsThatTrigger/WhatsThatTrigger.node.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsThatTrigger = void 0;
+const access_1 = require("../../shared/access");
 const runtime_1 = require("../../shared/runtime");
 const validation_1 = require("../../shared/validation");
 class WhatsThatTrigger {
@@ -23,7 +24,7 @@ class WhatsThatTrigger {
                     type: 'string',
                     default: '',
                     required: true,
-                    description: 'The unique session ID created in the WhatsThat Session node.',
+                    description: 'The unique session ID used in the WhatsThat node resource Session.',
                 },
                 {
                     displayName: 'Event',
@@ -31,6 +32,7 @@ class WhatsThatTrigger {
                     type: 'options',
                     default: 'message.received',
                     options: [
+                        { name: 'Link Chat Command', value: 'link.chat.command' },
                         { name: 'Message Received', value: 'message.received' },
                         { name: 'Message From Me', value: 'message.from_me' },
                         { name: 'Message Sent', value: 'message.sent' },
@@ -41,6 +43,18 @@ class WhatsThatTrigger {
                         { name: 'Group Participants', value: 'group.participants' },
                         { name: 'Any Event', value: '*' }
                     ],
+                },
+                {
+                    displayName: 'Link Command',
+                    name: 'linkCommand',
+                    type: 'string',
+                    default: '/link-whatsthat',
+                    description: 'Users must send this command followed by a space and the alias in the chat to link. Example: /link-whatsthat support',
+                    displayOptions: {
+                        show: {
+                            eventName: ['link.chat.command'],
+                        },
+                    },
                 }
             ],
         };
@@ -48,9 +62,39 @@ class WhatsThatTrigger {
     async trigger() {
         const sessionId = (0, validation_1.requireSessionId)(this.getNodeParameter('sessionId'));
         const eventName = this.getNodeParameter('eventName');
-        const handler = (event) => {
+        const linkCommand = this.getNodeParameter('linkCommand', '');
+        const access = await (0, access_1.buildAccess)(this);
+        const handler = async (event) => {
             if (event.sessionId !== sessionId)
                 return;
+            if (eventName === 'link.chat.command') {
+                if (event.event !== 'message.received')
+                    return;
+                const data = event.data;
+                const text = (0, runtime_1.extractMessageText)(data.message)?.trim();
+                const prefix = linkCommand.trim();
+                if (!text || !prefix || !text.startsWith(`${prefix} `))
+                    return;
+                const alias = text.slice(prefix.length).trim();
+                const jid = data.remoteJid;
+                if (!alias || !jid)
+                    return;
+                const linked = await runtime_1.registry.connectTarget(access, sessionId, alias, jid);
+                this.emit([
+                    [
+                        {
+                            json: {
+                                event: 'link.chat.command',
+                                sessionId,
+                                alias,
+                                jid,
+                                linked,
+                            },
+                        },
+                    ],
+                ]);
+                return;
+            }
             if (eventName !== '*' && event.event !== eventName)
                 return;
             this.emit([[{ json: event }]]);

package/dist/shared/context.d.ts

@@ -1,5 +1,5 @@
-import type { IDataObject, IExecuteFunctions, ILoadOptionsFunctions } from 'n8n-workflow';
-export type NodeContext = IExecuteFunctions | ILoadOptionsFunctions;
+import type { IDataObject, IExecuteFunctions, ILoadOptionsFunctions, ITriggerFunctions } from 'n8n-workflow';
+export type NodeContext = IExecuteFunctions | ILoadOptionsFunctions | ITriggerFunctions;
 export interface RuntimeConfig {
     storagePath: string;
 }

package/dist/shared/runtime.d.ts

@@ -13,6 +13,8 @@ type SendRequest = {
     sessionId: string;
     channelAlias?: string;
     jid?: string;
+    phoneNumber?: string;
+    sendToSelf?: boolean;
     type: 'text' | 'image' | 'video' | 'audio' | 'document' | 'reaction' | 'location' | 'contact' | 'poll';
     sendAsDocument?: boolean;
     message?: string;
@@ -46,7 +48,7 @@ declare class WhatsThatRegistry extends EventEmitter {
         phoneNumberForPairing?: string;
     }): Promise<SessionRecord>;
     connectSession(storageRoot: string, access: DataAccess, sessionId: string): Promise<SessionRecord>;
-    ensureConnectedSession(storageRoot: string, access: DataAccess, input: {
+    ensureConnectedSession(_storageRoot: string, access: DataAccess, input: {
         sessionId: string;
         label: string;
         phoneNumberForPairing?: string;
@@ -64,6 +66,7 @@ declare class WhatsThatRegistry extends EventEmitter {
     unlinkTarget(access: DataAccess, sessionId: string, alias: string): Promise<boolean>;
     sendMessage(access: DataAccess, request: SendRequest): Promise<Record<string, unknown>>;
     private buildContent;
+    private resolveTargetJid;
     private syncGroups;
     private rememberTarget;
     private upsertSession;
@@ -71,6 +74,7 @@ declare class WhatsThatRegistry extends EventEmitter {
     private emitRuntime;
     private waitForSessionState;
     private matchesWaitTarget;
+    waitForConnectedSession(access: DataAccess, sessionId: string, timeoutMs: number): Promise<SessionRecord>;
     private required;
     private buildQrCodeUrl;
 }

package/dist/shared/runtime.js

@@ -219,14 +219,14 @@ class WhatsThatRegistry extends node_events_1.EventEmitter {
         this.sockets.set(sessionId, socket);
         return (await this.getSession(access, sessionId)) ?? starting;
     }
-    async ensureConnectedSession(storageRoot, access, input, options) {
-        await this.ensureSession(storageRoot, access, input);
+    async ensureConnectedSession(_storageRoot, access, input, options) {
+        await this.ensureSession(_storageRoot, access, input);
         const current = await this.getSession(access, input.sessionId);
         if (!current) {
             throw new Error(`Unknown session ${input.sessionId}`);
         }
         if (!this.sockets.has(input.sessionId) && current.status !== 'connected') {
-            await this.connectSession(storageRoot, access, input.sessionId);
+            throw new Error(`Session ${input.sessionId} is not active. Run Connect Session first and keep the n8n runtime alive until pairing completes.`);
         }
         return this.waitForSessionState(access, input.sessionId, options?.waitFor ?? 'pairing_or_connected', options?.timeoutMs ?? 20000);
     }
@@ -317,11 +317,9 @@ class WhatsThatRegistry extends node_events_1.EventEmitter {
         if (!socket) {
             throw new Error(`Session ${request.sessionId} is not connected`);
         }
-        const linked = await this.listLinkedTargets(access, request.sessionId);
-        const targetJid = request.jid ??
-            linked.find((item) => item.alias === request.channelAlias)?.jid;
+        const targetJid = await this.resolveTargetJid(access, request, socket);
         if (!targetJid) {
-            throw new Error('Unknown target. Use a linked alias or raw JID.');
+            throw new Error('Unknown target. Use a linked chat, WhatsApp number, raw JID, or Yourself.');
         }
         const content = this.buildContent(request, targetJid);
         const response = await socket.sendMessage(targetJid, content, {
@@ -419,6 +417,28 @@ class WhatsThatRegistry extends node_events_1.EventEmitter {
                 };
         }
     }
+    async resolveTargetJid(access, request, socket) {
+        if (request.jid) {
+            return request.jid;
+        }
+        if (request.phoneNumber) {
+            return `${request.phoneNumber}@s.whatsapp.net`;
+        }
+        if (request.sendToSelf) {
+            const session = await this.getSession(access, request.sessionId);
+            const raw = session?.phone ?? socket.user?.id;
+            const normalized = raw?.split(':')[0];
+            if (!normalized) {
+                throw new Error(`Session ${request.sessionId} does not have a known WhatsApp number yet. Connect the session first.`);
+            }
+            return normalized;
+        }
+        if (request.channelAlias) {
+            const linked = await this.listLinkedTargets(access, request.sessionId);
+            return linked.find((item) => item.alias === request.channelAlias)?.jid;
+        }
+        return undefined;
+    }
     async syncGroups(access, sessionId, socket) {
         const groups = await socket.groupFetchAllParticipating();
         for (const [jid, data] of Object.entries(groups)) {
@@ -508,6 +528,16 @@ class WhatsThatRegistry extends node_events_1.EventEmitter {
         }
         return false;
     }
+    async waitForConnectedSession(access, sessionId, timeoutMs) {
+        const current = await this.getSession(access, sessionId);
+        if (!current) {
+            throw new Error(`Unknown session ${sessionId}`);
+        }
+        if (!this.sockets.has(sessionId) && current.status !== 'connected') {
+            throw new Error(`Session ${sessionId} is not active. Run Connect Session first and keep the n8n runtime alive until pairing completes.`);
+        }
+        return this.waitForSessionState(access, sessionId, 'connected', timeoutMs);
+    }
     required(value, field) {
         if (value === undefined || value === null || value === '') {
             throw new Error(`Missing required field ${field}`);

package/dist/shared/validation.d.ts

@@ -1,2 +1,4 @@
 export declare function normalizeSessionId(sessionId: string): string;
 export declare function requireSessionId(sessionId: string): string;
+export declare function normalizeWhatsappNumber(phoneNumber: string): string;
+export declare function requireWhatsappNumber(phoneNumber: string): string;

package/dist/shared/validation.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeSessionId = normalizeSessionId;
 exports.requireSessionId = requireSessionId;
+exports.normalizeWhatsappNumber = normalizeWhatsappNumber;
+exports.requireWhatsappNumber = requireWhatsappNumber;
 function normalizeSessionId(sessionId) {
     return sessionId.trim();
 }
@@ -12,3 +14,13 @@ function requireSessionId(sessionId) {
     }
     return normalized;
 }
+function normalizeWhatsappNumber(phoneNumber) {
+    return phoneNumber.trim().replace(/\s+/g, '').replace(/^\+/, '').replace(/^00/, '');
+}
+function requireWhatsappNumber(phoneNumber) {
+    const normalized = normalizeWhatsappNumber(phoneNumber);
+    if (!normalized || !/^\d+$/.test(normalized)) {
+        throw new Error('WhatsApp Number must contain digits only, including country code, without 00 or +.');
+    }
+    return normalized;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jep182/n8n-nodes-whatsthat",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "n8n community nodes with embedded Baileys runtime for multi-session chat automation",
   "license": "MIT",
   "main": "dist/index.js",
@@ -57,9 +57,7 @@
       "dist/credentials/WhatsThatRuntime.credentials.js"
     ],
     "nodes": [
-      "dist/nodes/WhatsThatSession/WhatsThatSession.node.js",
-      "dist/nodes/WhatsThatTargets/WhatsThatTargets.node.js",
-      "dist/nodes/WhatsThatMessage/WhatsThatMessage.node.js",
+      "dist/nodes/WhatsThat/WhatsThat.node.js",
       "dist/nodes/WhatsThatTrigger/WhatsThatTrigger.node.js"
     ]
   }