@pheem49/mint 1.5.1 → 1.5.2

package/src/Channels/discord_bridge.js

@@ -1,9 +1,15 @@
-const { Client, GatewayIntentBits, Partials } = require('discord.js');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class DiscordBridge {
     constructor(token) {
         this.token = token;
+        const { Client, GatewayIntentBits, Partials } = requireOptional(
+            'discord.js',
+            'npm install discord.js'
+        );
         this.client = new Client({
             intents: [
                 GatewayIntentBits.Guilds,
@@ -21,30 +27,22 @@ class DiscordBridge {
         });
 
         this.client.on('messageCreate', async (message) => {
-            // Ignore bot messages
             if (message.author.bot) return;
-
-            // Handle DMs or Mentions
             const isDM = !message.guild;
             const isMentioned = message.mentions.has(this.client.user);
 
             if (isDM || isMentioned) {
                 try {
-                    // Clean up the message if it's a mention
                     let cleanContent = message.content;
                     if (isMentioned) {
-                        cleanContent = message.content.replace(`<@!${this.client.user.id}>`, '').replace(`<@${this.client.user.id}>`, '').trim();
+                        cleanContent = message.content
+                            .replace(`<@!${this.client.user.id}>`, '')
+                            .replace(`<@${this.client.user.id}>`, '')
+                            .trim();
                     }
-
                     if (!cleanContent) return;
-
-                    // Show typing indicator
                     await message.channel.sendTyping();
-
-                    // Send to Mint AI Brain
                     const result = await handleChat(cleanContent);
-
-                    // Reply to user
                     if (result && result.response) {
                         await message.reply(result.response);
                     }

package/src/Channels/line_bridge.js

@@ -1,22 +1,25 @@
-const line = require('@line/bot-sdk');
-const express = require('express');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class LineBridge {
     constructor(credentials) {
+        this._line    = requireOptional('@line/bot-sdk', 'npm install @line/bot-sdk express');
+        this._express = requireOptional('express',       'npm install @line/bot-sdk express');
         this.config = {
             channelAccessToken: credentials.accessToken,
             channelSecret: credentials.secret,
         };
-        this.port = credentials.port || 3000;
-        this.client = new line.messagingApi.MessagingApiClient({
+        this.port   = credentials.port || 3000;
+        this.client = new this._line.messagingApi.MessagingApiClient({
             channelAccessToken: credentials.accessToken
         });
-        this.app = express();
+        this.app    = this._express();
     }
 
     async connect() {
-        this.app.post('/callback', line.middleware(this.config), (req, res) => {
+        this.app.post('/callback', this._line.middleware(this.config), (req, res) => {
             Promise
                 .all(req.body.events.map(event => this.handleEvent(event)))
                 .then((result) => res.json(result))
@@ -36,7 +39,6 @@ class LineBridge {
         if (event.type !== 'message' || event.message.type !== 'text') {
             return Promise.resolve(null);
         }
-
         try {
             const result = await handleChat(event.message.text);
             if (result && result.response) {
@@ -51,9 +53,7 @@ class LineBridge {
     }
 
     async disconnect() {
-        if (this.server) {
-            this.server.close();
-        }
+        if (this.server) this.server.close();
     }
 }
 

package/src/Channels/slack_bridge.js

@@ -1,8 +1,11 @@
-const { App } = require('@slack/bolt');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class SlackBridge {
     constructor(credentials) {
+        const { App } = requireOptional('@slack/bolt', 'npm install @slack/bolt');
         this.app = new App({
             token: credentials.botToken,
             appToken: credentials.appToken,
@@ -15,24 +18,18 @@ class SlackBridge {
             try {
                 const text = event.text.replace(/<@.*?>/g, '').trim();
                 if (!text) return;
-
                 const result = await handleChat(text);
-                if (result && result.response) {
-                    await say(result.response);
-                }
+                if (result && result.response) await say(result.response);
             } catch (err) {
                 console.error('[Slack Bridge] Error processing app_mention:', err);
             }
         });
 
         this.app.event('message', async ({ event, say }) => {
-            // Only respond in DMs
             if (event.channel_type === 'im') {
                 try {
                     const result = await handleChat(event.text);
-                    if (result && result.response) {
-                        await say(result.response);
-                    }
+                    if (result && result.response) await say(result.response);
                 } catch (err) {
                     console.error('[Slack Bridge] Error processing message:', err);
                 }
@@ -44,9 +41,7 @@ class SlackBridge {
     }
 
     async disconnect() {
-        if (this.app) {
-            await this.app.stop();
-        }
+        if (this.app) await this.app.stop();
     }
 }
 

package/src/Channels/telegram_bridge.js

@@ -1,9 +1,12 @@
-const { Telegraf } = require('telegraf');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class TelegramBridge {
     constructor(token) {
         this.token = token;
+        const { Telegraf } = requireOptional('telegraf', 'npm install telegraf');
         this.bot = new Telegraf(token);
     }
 
@@ -12,19 +15,11 @@ class TelegramBridge {
 
         this.bot.on('text', async (ctx) => {
             try {
-                // Show typing status
                 await ctx.sendChatAction('typing');
-
                 const message = ctx.message.text;
                 if (!message) return;
-
-                // Send to Mint AI Brain
                 const result = await handleChat(message);
-
-                // Reply to user
-                if (result && result.response) {
-                    await ctx.reply(result.response);
-                }
+                if (result && result.response) await ctx.reply(result.response);
             } catch (err) {
                 console.error('[Telegram Bridge] Error processing message:', err);
                 await ctx.reply('ขออภัยค่ะ เกิดข้อผิดพลาดบางอย่างในการประมวลผลข้อความ');
@@ -34,15 +29,12 @@ class TelegramBridge {
         this.bot.launch();
         console.log('[Telegram Bridge] Bot started!');
 
-        // Enable graceful stop
         process.once('SIGINT', () => this.bot.stop('SIGINT'));
         process.once('SIGTERM', () => this.bot.stop('SIGTERM'));
     }
 
     async disconnect() {
-        if (this.bot) {
-            await this.bot.stop();
-        }
+        if (this.bot) await this.bot.stop();
     }
 }
 

package/src/Channels/whatsapp_bridge.js

@@ -1,9 +1,16 @@
-const { Client, LocalAuth } = require('whatsapp-web.js');
-const qrcode = require('qrcode-terminal');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class WhatsappBridge {
     constructor() {
+        // Dynamic require — only loads if user has installed whatsapp-web.js
+        const { Client, LocalAuth } = requireOptional(
+            'whatsapp-web.js',
+            'npm install whatsapp-web.js qrcode-terminal'
+        );
+        this._qrcode = requireOptional('qrcode-terminal', 'npm install qrcode-terminal');
         this.client = new Client({
             authStrategy: new LocalAuth({
                 dataPath: require('path').join(require('os').homedir(), '.config', 'mint', 'whatsapp-session')
@@ -17,7 +24,7 @@ class WhatsappBridge {
     async connect() {
         this.client.on('qr', (qr) => {
             console.log('[WhatsApp Bridge] Scan this QR code to login:');
-            qrcode.generate(qr, { small: true });
+            this._qrcode.generate(qr, { small: true });
         });
 
         this.client.on('ready', () => {
@@ -26,13 +33,8 @@ class WhatsappBridge {
 
         this.client.on('message', async (msg) => {
             try {
-                // Ignore messages from groups unless mentioned (simple implementation)
                 const chat = await msg.getChat();
-                if (chat.isGroup) {
-                    // For groups, we could add a mention check here if desired
-                    return;
-                }
-
+                if (chat.isGroup) return;
                 const result = await handleChat(msg.body);
                 if (result && result.response) {
                     await msg.reply(result.response);

package/src/System/chat_history_manager.js

@@ -19,21 +19,29 @@ if (!fs.existsSync(CONFIG_DIR)) {
 
 const CHAT_HISTORY_PATH = path.join(CONFIG_DIR, 'mint-chat-history.json');
 
-// Migration Logic: Consolidate from Electron userData or old ~/.mint to ~/.config/mint
+// Migration Logic: Consolidate from various legacy locations to ~/.config/mint/
 if (!fs.existsSync(CHAT_HISTORY_PATH)) {
     const electronUserData = app && app.getPath ? path.join(app.getPath('userData'), 'mint-chat-history.json') : null;
-    const legacyPath = path.join(MINT_DIR, 'mint-chat-history.json');
+    const legacyDotMint    = path.join(MINT_DIR, 'mint-chat-history.json');
+    // Legacy: file was written to the project root (CWD) before v1.5.2
+    const legacyProjectRoot = path.join(process.cwd(), 'mint-chat-history.json');
 
-    if (electronUserData && fs.existsSync(electronUserData)) {
-        try {
-            fs.copyFileSync(electronUserData, CHAT_HISTORY_PATH);
-            console.log('[History] Migrated chat history from Electron userData');
-        } catch (e) { console.error('[History] Migration from Electron failed:', e); }
-    } else if (fs.existsSync(legacyPath)) {
-        try {
-            fs.copyFileSync(legacyPath, CHAT_HISTORY_PATH);
-            console.log('[History] Migrated chat history from ~/.mint');
-        } catch (e) { console.error('[History] Migration from ~/.mint failed:', e); }
+    const candidates = [
+        electronUserData,
+        legacyDotMint,
+        legacyProjectRoot
+    ].filter(Boolean);
+
+    for (const candidate of candidates) {
+        if (candidate !== CHAT_HISTORY_PATH && fs.existsSync(candidate)) {
+            try {
+                fs.copyFileSync(candidate, CHAT_HISTORY_PATH);
+                console.log(`[History] Migrated chat history from ${candidate}`);
+            } catch (e) {
+                console.error('[History] Migration failed:', e);
+            }
+            break;
+        }
     }
 }
 

package/src/System/optional_require.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * Helper: ลอง require package แบบ dynamic
+ * ถ้าหาไม่เจอให้ throw Error พร้อม install guide
+ */
+function requireOptional(pkg, installHint) {
+    try {
+        return require(pkg);
+    } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const hint = installHint || `npm install ${pkg}`;
+            throw new Error(
+                `[Mint] Optional package "${pkg}" is not installed.\n` +
+                `To use this feature, run: ${hint}\n` +
+                `(This package is not bundled by default to keep Mint lightweight.)`
+            );
+        }
+        throw e;
+    }
+}
+
+module.exports = { requireOptional };

package/src/UI/live2d_manager.js

@@ -7,6 +7,33 @@ window.Live2DManager = {
     resizeObserver: null,
     lipSyncInterval: null,
     expIndex: 0,
+    interactionEnabled: true,
+    interactionStorageKey: 'mint-model-interaction-enabled',
+    accessoryStorageKey: 'mint-live2d-accessories',
+    activeAccessories: {},
+    accessoryOrder: ['glasses', 'pen', 'cat'],
+    accessoryParams: {
+        glasses: { paramId: 'Param96', label: 'Glasses' },
+        pen: { paramId: 'Param68', label: 'Pen' },
+        cat: { paramId: 'Param54', label: 'Cat Filter' }
+    },
+    pointerTrackingEnabled: true,
+    pointerTrackingFrame: null,
+    pointerTracking: {
+        targetX: 0,
+        targetY: 0,
+        currentX: 0,
+        currentY: 0,
+        lastMoveAt: 0
+    },
+    pointerTrackingConfig: {
+        focusX: 0.35,
+        focusY: 0.35,
+        rangeX: 0.35,
+        rangeY: 0.35,
+        smoothing: 0.18
+    },
+    baseModelPosition: null,
     lastInteractionAt: 0,
     expressionToastTimeout: null,
     expressionParamIds: [
@@ -39,6 +66,8 @@ window.Live2DManager = {
 
     async loadModel(mountEl, statusEl, shellEl) {
         this.statusEl = statusEl; // Store for later use
+        this.interactionEnabled = this.getSavedInteractionEnabled();
+        this.activeAccessories = this.getSavedAccessories();
         if (!mountEl) return;
         if (statusEl) {
             statusEl.classList.remove('is-error');
@@ -74,7 +103,7 @@ window.Live2DManager = {
 
             const modelUrl = new URL('../../models/Shiroko_Model/Shiroko/Shiroko_Core/%E9%9D%A2%E9%A5%BC0.model3.json', window.location.href).href;
             this.model = await window.PIXI.live2d.Live2DModel.from(modelUrl, {
-                autoInteract: true
+                autoInteract: false
             });
             this.expressionToastEl = document.getElementById('expression-toast');
 
@@ -82,8 +111,9 @@ window.Live2DManager = {
             this.app.stage.addChild(this.model);
 
             // -- Interaction Setup --
-            this.model.interactive = true;
-            this.model.buttonMode = true;
+            this.setInteractionEnabled(this.interactionEnabled);
+            this.setupPointerTracking(mountEl);
+            this.applyAccessories();
 
             // Tap Interaction. This model does not define Cubism HitAreas, so use
             // normalized model coordinates to provide stable region reactions.
@@ -105,11 +135,15 @@ window.Live2DManager = {
                 const heightScale = mountHeight / Math.max(modelHeight, 1);
                 
                 // Reduced zoom to 2.0 as requested
-                const scale = Math.min(widthScale, heightScale) * 1.8;
+                const scale = Math.min(widthScale, heightScale) * 1.85;
 
                 this.model.scale.set(scale);
                 // Adjusted Y offset to 1.0 as requested
-                this.model.position.set(mountWidth / 2, mountHeight / 2 + mountHeight * 0.6);
+                this.baseModelPosition = {
+                    x: mountWidth / 2,
+                    y: mountHeight / 2 + mountHeight * 0.55
+                };
+                this.applyModelFollowOffset();
             };
 
             requestAnimationFrame(() => {
@@ -147,7 +181,7 @@ window.Live2DManager = {
     },
 
     handleModelTap(event) {
-        if (!this.model) return;
+        if (!this.model || !this.interactionEnabled) return;
 
         const now = Date.now();
         if (now - this.lastInteractionAt < 3000) return;
@@ -182,7 +216,7 @@ window.Live2DManager = {
             if (!point) return null;
             const { x, y } = point;
 
-            if (this.isPointInZone(x, y, 0.37, 0.395, 0.25, 0.13)) {
+            if (this.isPointInZone(x, y, 0.38, 0.40, 0.24, 0.115)) {
                 return {
                     id: 'face',
                     label: 'Cat Ears',
@@ -191,7 +225,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.35, 0.30, 0.29, 0.09)) {
+            if (this.isPointInZone(x, y, 0.34, 0.255, 0.32, 0.15)) {
                 return {
                     id: 'head',
                     label: 'Head Pat',
@@ -200,8 +234,8 @@ window.Live2DManager = {
                 };
             }
 
-            const isLeftHand = this.isPointInZone(x, y, 0.17, 0.65, 0.19, 0.17);
-            const isRightHand = this.isPointInZone(x, y, 0.70, 0.67, 0.17, 0.17);
+            const isLeftHand = this.isPointInZone(x, y, 0.22, 0.68, 0.20, 0.16);
+            const isRightHand = this.isPointInZone(x, y, 0.61, 0.68, 0.19, 0.16);
             if (isLeftHand || isRightHand) {
                 return {
                     id: isLeftHand ? 'left-hand' : 'right-hand',
@@ -211,7 +245,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.31, 0.76, 0.38, 0.24)) {
+            if (this.isPointInZone(x, y, 0.38, 0.77, 0.30, 0.23)) {
                 return {
                     id: 'lower-body',
                     label: 'Careful',
@@ -220,7 +254,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.36, 0.55, 0.29, 0.15)) {
+            if (this.isPointInZone(x, y, 0.37, 0.555, 0.29, 0.14)) {
                 return {
                     id: 'body',
                     label: 'Shoulder Tap',
@@ -271,6 +305,112 @@ window.Live2DManager = {
         this.showExpressionToast(`Expression: ${nextExp.label}`);
     },
 
+    setInteractionEnabled(isEnabled, persist = false) {
+        this.interactionEnabled = Boolean(isEnabled);
+        if (persist) {
+            this.saveInteractionEnabled(this.interactionEnabled);
+        }
+        if (!this.model) return;
+
+        this.model.interactive = this.interactionEnabled;
+        this.model.buttonMode = this.interactionEnabled;
+    },
+
+    getSavedInteractionEnabled() {
+        try {
+            return localStorage.getItem(this.interactionStorageKey) !== 'false';
+        } catch (_) {
+            return true;
+        }
+    },
+
+    saveInteractionEnabled(isEnabled) {
+        try {
+            localStorage.setItem(this.interactionStorageKey, String(Boolean(isEnabled)));
+        } catch (_) {}
+    },
+
+    setupPointerTracking(mountEl) {
+        if (!mountEl) return;
+
+        window.addEventListener('mousemove', (event) => this.updatePointerTrackingTarget(event, mountEl));
+
+        if (!this.pointerTrackingFrame) {
+            this.pointerTrackingFrame = () => this.updatePointerTracking();
+            this.app?.ticker?.add(this.pointerTrackingFrame);
+        }
+    },
+
+    updatePointerTrackingTarget(event, mountEl) {
+        if (!this.pointerTrackingEnabled || !mountEl) return;
+
+        const rect = {
+            left: 0,
+            top: 0,
+            width: window.innerWidth || mountEl.getBoundingClientRect().width,
+            height: window.innerHeight || mountEl.getBoundingClientRect().height
+        };
+        const config = this.pointerTrackingConfig;
+        const centerX = rect.left + rect.width * config.focusX;
+        const centerY = rect.top + rect.height * config.focusY;
+        const rangeX = Math.max(rect.width * config.rangeX, 1);
+        const rangeY = Math.max(rect.height * config.rangeY, 1);
+
+        this.pointerTracking.targetX = this.clamp((event.clientX - centerX) / rangeX, -1, 1);
+        this.pointerTracking.targetY = this.clamp((event.clientY - centerY) / rangeY, -1, 1);
+        this.pointerTracking.lastMoveAt = performance.now();
+    },
+
+    resetPointerTrackingTarget() {
+        this.pointerTracking.targetX = 0;
+        this.pointerTracking.targetY = 0;
+    },
+
+    updatePointerTracking() {
+        if (!this.model || !this.pointerTrackingEnabled) return;
+
+        const tracking = this.pointerTracking;
+        const smoothing = this.pointerTrackingConfig.smoothing;
+        tracking.currentX += (tracking.targetX - tracking.currentX) * smoothing;
+        tracking.currentY += (tracking.targetY - tracking.currentY) * smoothing;
+
+        const x = tracking.currentX;
+        const y = tracking.currentY;
+        const core = this.model?.internalModel?.coreModel;
+        if (!core) return;
+
+        this.setLive2DParam(core, 'ParamAngleX', x * 18);
+        this.setLive2DParam(core, 'ParamAngleY', -y * 14);
+        this.setLive2DParam(core, 'ParamAngleZ', -x * 5);
+        this.setLive2DParam(core, 'ParamEyeBallX', x * 1.45);
+        this.setLive2DParam(core, 'ParamEyeBallY', -y * 1.35);
+        this.setLive2DParam(core, 'Param49', x * 7);
+        this.setLive2DParam(core, 'Param51', -y * 5);
+        this.setLive2DParam(core, 'Param50', -x * 3);
+        this.applyModelFollowOffset();
+    },
+
+    applyModelFollowOffset() {
+        if (!this.model || !this.baseModelPosition) return;
+
+        const x = this.pointerTracking.currentX || 0;
+        const y = this.pointerTracking.currentY || 0;
+        this.model.position.set(
+            this.baseModelPosition.x + x * 22,
+            this.baseModelPosition.y + y * 16
+        );
+    },
+
+    setLive2DParam(core, id, value) {
+        try {
+            core.setParameterValueById(id, value);
+        } catch (_) {}
+    },
+
+    clamp(value, min, max) {
+        return Math.max(min, Math.min(max, value));
+    },
+
     showExpressionToast(text, duration = 1600) {
         const toast = this.expressionToastEl || document.getElementById('expression-toast');
         if (!toast) return;
@@ -296,6 +436,7 @@ window.Live2DManager = {
 
         try {
             this.model.expression(expressionId);
+            requestAnimationFrame(() => this.applyAccessories());
         } catch (error) {
             console.error(`[Live2D] Failed to apply expression: ${expressionId}`, error);
         }
@@ -328,7 +469,64 @@ window.Live2DManager = {
         }
 
         this.resetExpressionParams();
-        requestAnimationFrame(() => this.resetExpressionParams());
+        requestAnimationFrame(() => {
+            this.resetExpressionParams();
+            this.applyAccessories();
+        });
+    },
+
+    setAccessory(accessoryId, isEnabled, persist = false) {
+        if (!this.accessoryParams[accessoryId]) return;
+
+        this.activeAccessories[accessoryId] = Boolean(isEnabled);
+        if (persist) {
+            this.saveAccessories();
+        }
+        this.applyAccessory(accessoryId);
+    },
+
+    setExclusiveAccessory(accessoryId, persist = false) {
+        const nextAccessoryId = this.accessoryParams[accessoryId] ? accessoryId : null;
+        Object.keys(this.accessoryParams).forEach(id => {
+            this.activeAccessories[id] = id === nextAccessoryId;
+        });
+        if (persist) {
+            this.saveAccessories();
+        }
+        this.applyAccessories();
+        return nextAccessoryId;
+    },
+
+    getActiveAccessoryId() {
+        return this.accessoryOrder.find(id => this.activeAccessories[id]) || null;
+    },
+
+    applyAccessories() {
+        Object.keys(this.accessoryParams).forEach(accessoryId => {
+            this.applyAccessory(accessoryId);
+        });
+    },
+
+    applyAccessory(accessoryId) {
+        const accessory = this.accessoryParams[accessoryId];
+        const core = this.model?.internalModel?.coreModel;
+        if (!accessory || !core) return;
+
+        this.setLive2DParam(core, accessory.paramId, this.activeAccessories[accessoryId] ? 1 : 0);
+    },
+
+    getSavedAccessories() {
+        try {
+            return JSON.parse(localStorage.getItem(this.accessoryStorageKey) || '{}') || {};
+        } catch (_) {
+            return {};
+        }
+    },
+
+    saveAccessories() {
+        try {
+            localStorage.setItem(this.accessoryStorageKey, JSON.stringify(this.activeAccessories));
+        } catch (_) {}
     },
 
     startLipSync() {