@innovatorssoft/innovators-bot2 2.0.3 → 2.0.5

package/README.md

@@ -2,6 +2,11 @@
 
 A powerful WhatsApp client library that provides seamless integration between Baileys and WhatsApp-web.js style APIs. This library makes it easy to create WhatsApp bots and automation tools with a familiar interface.
 
+## Community
+
+> Join our Discord server for support, updates, and discussions:
+> https://discord.gg/G3RfM6FDHS
+
 ## Features
 
 - 🚀 Easy to use, familiar WhatsApp-web.js style API
@@ -91,6 +96,19 @@ await client.sendMessage('1234567890@s.whatsapp.net', {
 })
 ```
 
+### Call Methods
+
+```javascript
+// Initiate a voice call
+const { callId } = await client.initiateCall(jid)
+
+// Initiate a video call
+const videoCall = await client.initiateCall(jid, { isVideo: true })
+
+// Cancel an outgoing call
+await client.cancelCall(callId, jid)
+```
+
 ### 2. Media Handling
 
 ```javascript
@@ -290,6 +308,12 @@ await client.updateGroupsAddPrivacy('contacts')
 // Update default disappearing mode for new chats
 // Options: 0 (off), 86400 (24h), 604800 (7d), 7776000 (90d)
 await client.updateDefaultDisappearingMode(604800)
+
+// Update profile status
+await client.updateProfileStatus('Hello World!')
+
+// Update profile name
+await client.updateProfileName('My name')
 ```
 
 ### 7. Interactive Messages
@@ -385,10 +409,85 @@ await client.SendList('1234567890@s.whatsapp.net', {
 });
 ```
 
-### 8. Message History
+#### Interactive Messages (V2)
+
+Modern interactive message generation with simplified API.
+
+**Quick Reply Buttons (V2)**
+```javascript
+await client.sendQuickReplyV2(jid, 'Please select an option below:', [
+    { id: 'btn-1', displayText: '✅ Accept' },
+    { id: 'btn-2', displayText: '❌ Reject' }
+], { footer: 'Powered by Innovators Soft' });
+```
+
+**URL Button (V2)**
+```javascript
+await client.sendUrlButtonV2(jid, 'Visit our website for more info', [
+    { displayText: '🌐 Open Website', url: 'https://example.com' }
+], { title: 'Product Info', footer: 'Click to open' });
+```
+
+**Copy Code Button (V2)**
+```javascript
+await client.sendCopyCodeV2(jid, 'Your OTP Code is:', '123456', '📋 Copy Code');
+```
+
+**Combined Buttons (Mix URL, Reply, Copy, Call) (V2)**
+```javascript
+await client.sendCombinedButtonsV2(jid, 'Choose an action:', [
+    { type: 'reply', displayText: '🛒 Order Now', id: 'order' },
+    { type: 'url', displayText: '🌐 Website', url: 'https://example.com' },
+    { type: 'call', displayText: '📞 Phone', phoneNumber: '+923224559543' },
+    { type: 'copy', displayText: '📋 Copy Promo', copyCode: 'PROMO2024' }
+], { title: 'Main Menu', footer: 'Innovators Soft' });
+```
+
+**List Message (V2)**
+```javascript
+await client.sendListV2(jid, {
+    title: '📋 Product Menu',
+    buttonText: 'View Menu',
+    description: 'Please select a product',
+    footer: 'Powered by Innovators Soft',
+    sections: [
+        {
+            title: 'Food',
+            rows: [
+                { rowId: 'nasi-goreng', title: 'Fried Rice', description: '$2.50' },
+                { rowId: 'mie-goreng', title: 'Fried Noodles', description: '$2.00' }
+            ]
+        }
+    ]
+});
+```
+
+### 8. Typing & Presence Control
+
+Use `createPresenceController` for manual or standalone typing/recording presence control — without needing the auto-reply system.
 
 ```javascript
-### 8. Message Store (History)
+const typing = client.createPresenceController();
+
+// Show "typing..." for 2 s, then send the message — all in one call
+const sent = await typing.simulateTyping(jid, 2000, async () => {
+    await client.sendMessage(jid, 'Here is your answer! ✅');
+});
+
+// Manual start (auto-pauses after 5 s by default)
+await typing.startTyping(jid, { duration: 5000 });
+
+// Manual stop
+await typing.stopTyping(jid);
+
+// Voice note recording indicator
+await typing.startRecording(jid, { duration: 3000 });
+
+// Stop all active indicators (e.g. on socket close)
+await typing.stopAll();
+```
+
+### 9. Message History (Store)
 
 The library includes a robust message store to keep track of chat history, even across reloads.
 
@@ -528,6 +627,8 @@ The library includes example bot commands that you can use:
 - `!readreceiptprivacy <value>` - Update read receipts privacy (all/none)
 - `!groupaddprivacy <value>` - Update who can add you to groups (all/contacts/contact_blacklist)
 - `!disappearing <seconds>` - Update default disappearing mode (0/86400/604800/7776000)
+- `!updatestatus <text>` - Update profile status
+- `!updatename <text>` - Update profile name
 
 ### Interactive Messages
 - `!buttons` - Show interactive buttons

package/example.js

@@ -9,6 +9,10 @@ const rl = readline.createInterface({
     output: process.stdout
 });
 
+String.prototype.toTitleCase = function () {
+    return this.split(' ').map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(' ');
+};
+
 const question = (text) => new Promise((resolve) => rl.question(text, resolve));
 
 async function start() {
@@ -167,6 +171,10 @@ async function start() {
     });
 
     // Listen for incoming messages
+    let lastOutgoingCallId = null;
+    let lastOutgoingCallJid = null;
+    let autoCancelCallTimer = null;
+
     client.on('message', async msg => {
 
         if (msg.body === '') {
@@ -363,6 +371,140 @@ async function start() {
                 });
                 break
 
+            case '!quickreplyv2':
+                await client.sendQuickReplyV2(msg.from, 'Please select an option below:', [
+                    { id: 'btn-1', displayText: '✅ Accept' },
+                    { id: 'btn-2', displayText: '❌ Reject' },
+                    { id: 'btn-3', displayText: '📞 Contact Support' }
+                ], { footer: 'Powered by Innovators Soft' });
+                break
+
+            case '!urlbuttonv2':
+                await client.sendUrlButtonV2(msg.from, 'Visit our website for more info', [
+                    { displayText: '🌐 Open Website', url: 'https://example.com' }
+                ], { title: 'Product Info', footer: 'Click to open' });
+                break
+
+            case '!copycodev2':
+                await client.sendCopyCodeV2(msg.from, 'Your OTP Code is:', '123456', '📋 Copy Code');
+                break
+
+            case '!combinedv2':
+                await client.sendCombinedButtonsV2(msg.from, 'Choose an action:', [
+                    { type: 'reply', displayText: '🛒 Order Now', id: 'order' },
+                    { type: 'url', displayText: '🌐 Website', url: 'https://example.com' },
+                    { type: 'call', displayText: '📞 Phone', phoneNumber: '+923224559543' },
+                    { type: 'copy', displayText: '📋 Copy Promo', copyCode: 'PROMO2024' }
+                ], { title: 'Main Menu', footer: 'Innovators Soft' });
+                break
+
+            case '!listv2':
+                await client.sendListV2(msg.from, {
+                    title: '📋 Product Menu',
+                    buttonText: 'View Menu',
+                    description: 'Please select a product',
+                    footer: 'Powered by Innovators Soft',
+                    sections: [
+                        {
+                            title: 'Food',
+                            rows: [
+                                { rowId: 'nasi-goreng', title: 'Fried Rice', description: '$2.50' },
+                                { rowId: 'mie-goreng', title: 'Fried Noodles', description: '$2.00' }
+                            ]
+                        },
+                        {
+                            title: 'Beverages',
+                            rows: [
+                                { rowId: 'es-teh', title: 'Ice Tea', description: '$0.50' },
+                                { rowId: 'kopi', title: 'Coffee', description: '$1.00' }
+                            ]
+                        }
+                    ]
+                });
+                break
+
+
+            case '!call':
+                try {
+                    if (autoCancelCallTimer) {
+                        clearTimeout(autoCancelCallTimer);
+                        autoCancelCallTimer = null;
+                    }
+                    const result = await client.initiateCall(msg.from);
+                    lastOutgoingCallId = result?.callId || null;
+                    lastOutgoingCallJid = msg.from;
+
+                    await client.sendMessage(msg.from, `Calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
+
+                    if (lastOutgoingCallId) {
+                        autoCancelCallTimer = setTimeout(async () => {
+                            try {
+                                await client.cancelCall(lastOutgoingCallId, lastOutgoingCallJid);
+                            } catch (error) {
+                                console.error('Error auto-canceling call:', error);
+                            } finally {
+                                lastOutgoingCallId = null;
+                                lastOutgoingCallJid = null;
+                                autoCancelCallTimer = null;
+                            }
+                        }, 10000);
+                    }
+                } catch (error) {
+                    console.error('Error initiating voice call:', error);
+                    await client.sendMessage(msg.from, 'Failed to initiate call');
+                }
+                break
+
+            case '!videocall':
+                try {
+                    if (autoCancelCallTimer) {
+                        clearTimeout(autoCancelCallTimer);
+                        autoCancelCallTimer = null;
+                    }
+                    const result = await client.initiateCall(msg.from, { isVideo: true });
+                    lastOutgoingCallId = result?.callId || null;
+                    lastOutgoingCallJid = msg.from;
+                    await client.sendMessage(msg.from, `Video calling... CallId: ${lastOutgoingCallId || 'unknown'}`);
+
+                    if (lastOutgoingCallId) {
+                        autoCancelCallTimer = setTimeout(async () => {
+                            try {
+                                await client.cancelCall(lastOutgoingCallId, lastOutgoingCallJid);
+                            } catch (error) {
+                                console.error('Error auto-canceling video call:', error);
+                            } finally {
+                                lastOutgoingCallId = null;
+                                lastOutgoingCallJid = null;
+                                autoCancelCallTimer = null;
+                            }
+                        }, 10000);
+                    }
+                } catch (error) {
+                    console.error('Error initiating video call:', error);
+                    await client.sendMessage(msg.from, 'Failed to initiate video call');
+                }
+                break
+
+            case '!cancelcall':
+                try {
+                    if (autoCancelCallTimer) {
+                        clearTimeout(autoCancelCallTimer);
+                        autoCancelCallTimer = null;
+                    }
+                    if (!lastOutgoingCallId) {
+                        await client.sendMessage(msg.from, 'No outgoing call to cancel');
+                        break;
+                    }
+                    await client.cancelCall(lastOutgoingCallId, msg.from);
+                    await client.sendMessage(msg.from, `Canceled call: ${lastOutgoingCallId}`);
+                    lastOutgoingCallId = null;
+                    lastOutgoingCallJid = null;
+                } catch (error) {
+                    console.error('Error canceling call:', error);
+                    await client.sendMessage(msg.from, 'Failed to cancel call');
+                }
+                break
+
             case '!help':
                 const help = `*📋 Available Commands List*\n\n` +
                     `*🔹 Basic Commands*\n` +
@@ -416,11 +558,23 @@ async function start() {
                     `• !statusprivacy <value> - Update status privacy\n` +
                     `• !readreceiptprivacy <value> - Update read receipts\n` +
                     `• !groupaddprivacy <value> - Who can add to groups\n` +
-                    `• !disappearing <seconds> - Default disappearing mode\n\n` +
+                    `• !disappearing <seconds> - Default disappearing mode\n` +
+                    `• !updatestatus <text> - Update profile status\n` +
+                    `• !updatename <text> - Update profile name\n\n` +
 
                     `*🎛️ Templates & Buttons*\n` +
                     `• !buttons - Button template\n` +
-                    `• !list - Scrollable list\n\n` +
+                    `• !list - Scrollable list\n` +
+                    `• !quickreplyv2 - Quick reply buttons V2\n` +
+                    `• !urlbuttonv2 - URL button V2\n` +
+                    `• !copycodev2 - Copy code button V2\n` +
+                    `• !combinedv2 - Mixed buttons V2\n` +
+                    `• !listv2 - Interactive list V2\n\n` +
+
+                    `*📞 Calls*\n` +
+                    `• !call - Initiate a voice call\n` +
+                    `• !videocall - Initiate a video call\n` +
+                    `• !cancelcall - Cancel last outgoing call\n\n` +
 
                     `*� Message Store*\n` +
                     `• !messages - Get stored messages for this chat\n` +
@@ -442,6 +596,10 @@ async function start() {
                     `• !typing - Show typing indicator\n` +
                     `• !recording - Show recording indicator\n` +
                     `• !paused - Clear typing or recording indicator\n` +
+                    `• !typing_simulate - Simulate typing for 5s then send msg\n` +
+                    `• !typing_start - Start typing with auto-pause\n` +
+                    `• !typing_stop - Stop typing indicator\n` +
+                    `• !recording_start - Start recording indicator\n` +
                     `• !logout - End session\n\n` +
 
                     `*📝 Note*:\nReplace <number> with phone number\n(without + or spaces)`
@@ -635,6 +793,40 @@ async function start() {
                 await client.sendMessage(msg.from, 'Stopped typing/recording indicator sent!');
                 break;
 
+            case '!typing_simulate':
+                // Show "typing..." for 5 seconds, then send the message — all in one call
+                await client.sendMessage(msg.from, 'Simulating typing for 5 seconds...');
+                const typing = client.createPresenceController();
+                await typing.simulateTyping(msg.from, 5000, async () => {
+                    await client.sendMessage(msg.from, 'This message was sent after 5 seconds of typing! ✅');
+                });
+                break;
+
+            case '!typing_start':
+                // Manual start (auto-pauses after 5 s by default if not specified)
+                const typingStart = client.createPresenceController();
+                await typingStart.startTyping(msg.from, { duration: 10000 }); // Show for 10s
+                await client.sendMessage(msg.from, 'Typing indicator started for 10 seconds.');
+                break;
+
+            case '!typing_stop':
+                const typingStop = client.createPresenceController();
+                await typingStop.stopTyping(msg.from);
+                await client.sendMessage(msg.from, 'Typing indicator stopped.');
+                break;
+
+            case '!recording_start':
+                const recordingIndicator = client.createPresenceController();
+                await recordingIndicator.startRecording(msg.from, { duration: 5000 });
+                await client.sendMessage(msg.from, 'Recording indicator started for 5 seconds.');
+                break;
+
+            case '!typing_stop_all':
+                const typingStopAll = client.createPresenceController();
+                await typingStopAll.stopAll();
+                await client.sendMessage(msg.from, 'All active indicators for this controller stopped.');
+                break;
+
             case '!read':
                 await client.readMessage(msg.raw.key);
                 await client.sendMessage(msg.from, 'Message marked as read!');
@@ -1261,6 +1453,35 @@ async function start() {
                 }
                 break;
 
+            case '!updatestatus':
+                try {
+                    if (!args) {
+                        await client.sendMessage(msg.from, '❌ Please provide a new status.\nUsage: !updatestatus <text>');
+                        break;
+                    }
+                    await client.updateProfileStatus(args.trim());
+                    await client.sendMessage(msg.from, `✅ Profile status updated successfully!`);
+                } catch (error) {
+                    console.error('Error updating profile status:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to update profile status: ${error.message}`);
+                }
+                break;
+
+            case '!updatename':
+                try {
+                    if (!args) {
+                        await client.sendMessage(msg.from, '❌ Please provide a new name.\nUsage: !updatename <text>');
+                        break;
+                    }
+                    const newName = args.trim().toTitleCase();
+                    await client.updateProfileName(newName);
+                    await client.sendMessage(msg.from, `✅ *${newName}* \nProfile name updated successfully!`);
+                } catch (error) {
+                    console.error('Error updating profile name:', error);
+                    await client.sendMessage(msg.from, `❌ Failed to update profile name: ${error.message}`);
+                }
+                break;
+
             case '!messages':
                 const history = client.getStoredMessages(msg.from);
                 let historyText = `*💾 Stored Messages for this chat (${history.length}):*\n\n`;

package/index.js

@@ -14,7 +14,14 @@ const {
     // Anti-Delete
     MessageStore,
     createMessageStoreHandler,
-    createAntiDeleteHandler
+    createAntiDeleteHandler,
+    createTypingIndicator,
+    generateInteractiveButtonMessage,
+    generateInteractiveListMessage,
+    generateCombinedButtons,
+    generateCopyCodeButton,
+    generateUrlButtonMessage,
+    generateQuickReplyButtons
 } = require('@innovatorssoft/baileys');
 
 const { Sticker, StickerTypes } = require('wa-sticker-formatter');
@@ -119,16 +126,15 @@ class WhatsAppClient extends EventEmitter {
 
     async connect() {
         try {
+            if (this._connectionState === 'connecting' && this.sock) {
+                return; // Prevent concurrent connection attempts
+            }
 
             if (this._connectionState !== 'connecting') {
                 this._connectionState = 'connecting';
                 this.emit('connecting', 'Connecting to WhatsApp...');
             }
 
-            const browserConfig = this.authmethod === 'pairing'
-                ? Browsers.iOS('chrome')
-                : ["Innovators Soft", "chrome", "1000.26100.275.0"];
-
             const { version: baileysVersion, isLatest: baileysIsLatest } = await fetchLatestBaileysVersion();
             const { version: waWebVersion, isLatest: waWebIsLatest } = await fetchLatestWaWebVersion();
 
@@ -147,7 +153,7 @@ class WhatsAppClient extends EventEmitter {
                 generateHighQualityLinkPreview: true,
                 linkPreviewImageThumbnailWidth: 192,
                 emitOwnEvents: true,
-                browser: browserConfig,
+                browser: Browsers.android('Innovators Soft'),
                 version: waWebVersion,
                 cachedGroupMetadata: async (jid) => {
                     const cached = this.groupMetadataCache.get(jid);
@@ -440,6 +446,7 @@ class WhatsAppClient extends EventEmitter {
 
                 try {
                     for (const reaction of reactions) {
+
                         // Get the chat JID, preferring PN over LID
                         let jid = reaction.key.remoteJid;
                         if (typeof reaction.key.remoteJidAlt === 'string' &&
@@ -913,6 +920,80 @@ class WhatsAppClient extends EventEmitter {
             throw error;
         }
     }
+
+    /**
+     * Send Quick Reply Buttons (V2)
+     * @param {string} jid - Target JID
+     * @param {string} text - Message text
+     * @param {Array<object>} buttons - Array of { id, displayText }
+     * @param {object} options - { footer }
+     */
+    async sendQuickReplyV2(jid, text, buttons, options = {}) {
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateQuickReplyButtons(text, buttons, options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Generic Interactive Button Message (V2)
+     * @param {string} jid - Target JID
+     * @param {object} options - Button options
+     */
+    async sendInteractiveButtonV2(jid, options) {
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateInteractiveButtonMessage(options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send URL Button (V2)
+     * @param {string} jid - Target JID
+     * @param {string} text - Message text
+     * @param {Array<object>} buttons - Array of { displayText, url }
+     * @param {object} options - { title, footer }
+     */
+    async sendUrlButtonV2(jid, text, buttons, options = {}) {
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateUrlButtonMessage(text, buttons, options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Copy Code Button (V2)
+     * @param {string} jid - Target JID
+     * @param {string} text - Message text
+     * @param {string} code - Code to be copied
+     * @param {string} buttonText - Text on the copy button
+     */
+    async sendCopyCodeV2(jid, text, code, buttonText) {
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateCopyCodeButton(text, code, buttonText);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Combined Buttons (V2)
+     * @param {string} jid - Target JID
+     * @param {string} text - Message text
+     * @param {Array<object>} buttons - Mix of { type: 'reply'|'url'|'call'|'copy', ... }
+     * @param {object} options - { title, footer }
+     */
+    async sendCombinedButtonsV2(jid, text, buttons, options = {}) {
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateCombinedButtons(text, buttons, options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
+
+    /**
+     * Send Interactive List Message (V2)
+     * @param {string} jid - Target JID
+     * @param {object} options - List options (title, buttonText, description, footer, sections)
+     */
+    async sendListV2(jid, options) {
+        if (!this.isConnected) throw new Error('Client is not connected');
+        const message = generateInteractiveListMessage(options);
+        return await this.sock.sendMessage(jid, message, { ai: true });
+    }
     /**
      * Send an external ad reply with a local image
      * @param {string} number - The phone number to send the ad to
@@ -1230,6 +1311,32 @@ class WhatsAppClient extends EventEmitter {
         }
     }
 
+    async initiateCall(jid, options = {}) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            return await this.sock.initiateCall(jid, options);
+        } catch (error) {
+            console.error('Error initiating call:', error);
+            throw error;
+        }
+    }
+
+    async cancelCall(callId, jid) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            return await this.sock.cancelCall(callId, jid);
+        } catch (error) {
+            console.error('Error canceling call:', error);
+            throw error;
+        }
+    }
+
     /**
      * Get the underlying socket instance
      * @returns {object} The socket instance
@@ -1268,6 +1375,17 @@ class WhatsAppClient extends EventEmitter {
         await this.sock.sendPresenceUpdate("paused", jid);
     }
 
+    /**
+     * Create a typing indicator controller for manual or standalone presence control
+     * @returns {object} The typing indicator controller
+     */
+    createPresenceController() {
+        if (!this.sock) throw new Error('Client is not connected');
+        return createTypingIndicator(
+            (jid, presence) => this.sock.sendPresenceUpdate(presence, jid)
+        );
+    }
+
     /**
      * Reinitialize the WhatsApp client by clearing the session and reconnecting
      * @returns {Promise<void>}
@@ -2348,6 +2466,42 @@ class WhatsAppClient extends EventEmitter {
         }
     }
 
+    /**
+     * Update profile status (about)
+     * @param {string} status - The new status message
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async updateProfileStatus(status) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            await this.sock.updateProfileStatus(status);
+        } catch (error) {
+            console.error('Error updating profile status:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Update profile name
+     * @param {string} name - The new profile name
+     * @returns {Promise<void>}
+     * @throws {Error} If client is not connected or update fails
+     */
+    async updateProfileName(name) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+        try {
+            await this.sock.updateProfileName(name);
+        } catch (error) {
+            console.error('Error updating profile name:', error);
+            throw error;
+        }
+    }
+
     /**
      * Add EXIF metadata to an existing WebP buffer
      * @param {Buffer} buffer - WebP buffer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@innovatorssoft/innovators-bot2",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "WhatsApp API",
   "main": "index.js",
   "scripts": {

package/publish-dual.js

@@ -1,40 +0,0 @@
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const packagePath = path.join(__dirname, 'package.json');
-
-// Read the original package.json
-const originalPackage = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-const originalName = originalPackage.name;
-
-console.log('🚀 Starting dual npm publish...\n');
-
-try {
-    // Step 1: Publish as unscoped package (innovators-bot2)
-    console.log(`📦 Publishing as "${originalName}"...`);
-    execSync('npm publish', { stdio: 'inherit', cwd: __dirname });
-    console.log(`✅ Successfully published "${originalName}"\n`);
-
-    // Step 2: Change name to scoped package
-    const scopedName = '@innovatorssoft/innovators-bot2';
-    console.log(`📦 Publishing as "${scopedName}"...`);
-    
-    originalPackage.name = scopedName;
-    fs.writeFileSync(packagePath, JSON.stringify(originalPackage, null, 2) + '\n');
-
-    // Step 3: Publish as scoped package with public access
-    execSync('npm publish --access public', { stdio: 'inherit', cwd: __dirname });
-    console.log(`✅ Successfully published "${scopedName}"\n`);
-
-} catch (error) {
-    console.error('❌ Error during publish:', error.message);
-    process.exitCode = 1;
-} finally {
-    // Step 4: Always restore original package.json
-    console.log('🔄 Restoring original package.json...');
-    originalPackage.name = originalName;
-    fs.writeFileSync(packagePath, JSON.stringify(originalPackage, null, 2) + '\n');
-    console.log('✅ Original package.json restored');
-    console.log('\n🎉 Dual publish complete!');
-}