@pheem49/mint 1.2.1

package/src/System/custom_workflows.js

@@ -0,0 +1,127 @@
+const fs = require('fs');
+const path = require('path');
+const { app, shell } = require('electron');
+const { exec } = require('child_process');
+
+class CustomWorkflows {
+    constructor() {
+        this.configPath = path.join(app.getPath('userData'), 'workflows.json');
+        this.workflows = [];
+        this.lastTriggered = {};
+        this.cooldownMs = 60 * 60 * 1000; // 1 hour cooldown per rule
+        this.checkIntervalMs = 15000;     // 15 seconds poll rate
+        this.timer = null;
+        this.webContents = null;
+        
+        this.ensureConfigExists();
+        this.loadWorkflows();
+    }
+    
+    ensureConfigExists() {
+        if (!fs.existsSync(this.configPath)) {
+            const defaultWorkflows = [
+                {
+                    id: "wf-1",
+                    name: "Check Mic on Zoom",
+                    trigger: { type: "process_running", processName: "zoom" },
+                    action: { type: "system_info", message: "Looks like you opened Zoom! Should I check your system resources? 📸", target: "" }
+                },
+                {
+                    id: "wf-2",
+                    name: "Coding Time",
+                    trigger: { type: "process_running", processName: "code" },
+                    action: { type: "open_app", target: "spotify", message: "Coding time! Want me to open Spotify for you? 🎧" }
+                }
+            ];
+            fs.writeFileSync(this.configPath, JSON.stringify(defaultWorkflows, null, 4), 'utf-8');
+        }
+    }
+    
+    loadWorkflows() {
+        try {
+            const raw = fs.readFileSync(this.configPath, 'utf-8');
+            this.workflows = JSON.parse(raw);
+            console.log(`[CustomWorkflows] Loaded ${this.workflows.length} rules.`);
+        } catch (e) {
+            console.error("[CustomWorkflows] Failed to load workflows.json", e);
+            this.workflows = [];
+        }
+    }
+    
+    startMonitoring(webContents) {
+        this.webContents = webContents;
+        if (this.timer) clearInterval(this.timer);
+        this.timer = setInterval(() => this.checkProcesses(), this.checkIntervalMs);
+        console.log('[CustomWorkflows] Started process monitoring.');
+    }
+    
+    stopMonitoring() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    
+    openConfigFile() {
+        // Try to open directly in VS Code since .json might natively open in a browser
+        exec(`code "${this.configPath}"`, (err) => {
+            if (err) {
+                // Fallback: Open the folder containing the config file
+                shell.showItemInFolder(this.configPath);
+                console.log("[CustomWorkflows] Opened folder instead since VS Code wasn't found in PATH.");
+            }
+        });
+    }
+    
+    async checkProcesses() {
+        if (!this.workflows || this.workflows.length === 0) return;
+        
+        try {
+            // Linux check using ps to get process names
+            exec('ps -A -o comm=', (err, stdout) => {
+                if (err) return; 
+                const runningProcesses = stdout.toLowerCase();
+                
+                for (const wf of this.workflows) {
+                    if (wf.trigger && wf.trigger.type === 'process_running' && wf.trigger.processName) {
+                        const targetName = wf.trigger.processName.toLowerCase();
+                        // simplistic exact-word match to avoid partial matches
+                        const regex = new RegExp(`^${targetName}$`, 'm');
+                        const isRunning = regex.test(runningProcesses);
+                        
+                        if (isRunning) {
+                            const lastTime = this.lastTriggered[wf.id] || 0;
+                            const now = Date.now();
+                            
+                            // Cooldown mechanism
+                            if (now - lastTime > this.cooldownMs) {
+                                this.triggerWorkflow(wf);
+                                this.lastTriggered[wf.id] = now;
+                            }
+                        }
+                    }
+                }
+            });
+        } catch (error) {
+            console.error("Workflow check error:", error);
+        }
+    }
+    
+    triggerWorkflow(wf) {
+        if (!this.webContents || this.webContents.isDestroyed()) return;
+        
+        console.log(`[CustomWorkflows] Triggering workflow: ${wf.name}`);
+        
+        const suggestion = {
+            message: wf.action.message || `💡 Automation triggered: ${wf.name}`,
+            suggestions: [
+                { label: "Yes, please", action: wf.action },
+                { label: "Dismiss", action: { type: "none" } }
+            ]
+        };
+        
+        this.webContents.send('proactive-suggestion', suggestion);
+    }
+}
+
+module.exports = new CustomWorkflows();

package/src/System/daemon_manager.js

@@ -0,0 +1,67 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const os = require('os');
+
+/**
+ * Installs Mint as a systemd user service
+ */
+async function installDaemon() {
+    if (process.platform !== 'linux') {
+        throw new Error('Daemon installation is currently only supported on Linux (systemd).');
+    }
+
+    const homeDir = os.homedir();
+    const serviceDir = path.join(homeDir, '.config', 'systemd', 'user');
+    const servicePath = path.join(serviceDir, 'mint-agent.service');
+
+    // Create systemd user directory if it doesn't exist
+    if (!fs.existsSync(serviceDir)) {
+        fs.mkdirSync(serviceDir, { recursive: true });
+    }
+
+    const nodePath = execSync('which node').toString().trim() || '/usr/bin/node';
+    const projectPath = path.resolve(__dirname, '../../');
+    const cliPath = path.join(projectPath, 'mint-cli.js');
+
+    const serviceContent = `[Unit]
+Description=Mint AI Background Agent
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${projectPath}
+ExecStart=${nodePath} ${cliPath} agent
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+
+    fs.writeFileSync(servicePath, serviceContent);
+
+    try {
+        console.log('[Daemon] Reloading systemd user daemon...');
+        execSync('systemctl --user daemon-reload');
+        
+        console.log(`[Daemon] Enabling and starting mint-agent.service...`);
+        execSync('systemctl --user enable mint-agent.service');
+        execSync('systemctl --user start mint-agent.service');
+
+        return `Mint Agent installed and started! Check logs with: journalctl --user -u mint-agent -f`;
+    } catch (err) {
+        throw new Error(`Failed to configure systemd: ${err.message}`);
+    }
+}
+
+async function stopDaemon() {
+    try {
+        execSync('systemctl --user stop mint-agent.service');
+        return "Daemon stopped.";
+    } catch (err) {
+        throw new Error(`Failed to stop daemon: ${err.message}`);
+    }
+}
+
+module.exports = { installDaemon, stopDaemon };

package/src/System/system_automation.js

@@ -0,0 +1,88 @@
+const { exec } = require('child_process');
+
+/**
+ * Executes a shell command and returns a promise.
+ */
+function execPromise(command) {
+    return new Promise((resolve, reject) => {
+        exec(command, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}
+
+/**
+ * Linux System Automation Logic
+ */
+const SystemAutomation = {
+    // Volume Control (Using amixer / pulseaudio)
+    async setVolume(percent) {
+        // Try amixer first (common on many distros)
+        try {
+            await execPromise(`amixer -D pulse sset Master ${percent}%`);
+            return `Volume set to ${percent}%`;
+        } catch (e) {
+            try {
+                await execPromise(`pactl set-sink-volume @DEFAULT_SINK@ ${percent}%`);
+                return `Volume set to ${percent}%`;
+            } catch (err) {
+                throw new Error("Failed to set volume. amixer or pactl not found.");
+            }
+        }
+    },
+
+    async mute() {
+        try {
+            await execPromise(`amixer -D pulse sset Master toggle`);
+            return "Volume toggled (mute/unmute)";
+        } catch (e) {
+            await execPromise(`pactl set-sink-mute @DEFAULT_SINK@ toggle`);
+            return "Volume toggled (mute/unmute)";
+        }
+    },
+
+    // Brightness Control (Using brightnessctl or xbacklight)
+    async setBrightness(percent) {
+        try {
+            // brightnessctl is modern and common on Wayland/X11
+            await execPromise(`brightnessctl set ${percent}%`);
+            return `Brightness set to ${percent}%`;
+        } catch (e) {
+            try {
+                await execPromise(`xbacklight -set ${percent}`);
+                return `Brightness set to ${percent}%`;
+            } catch (err) {
+                throw new Error("Failed to set brightness. brightnessctl or xbacklight not found.");
+            }
+        }
+    },
+
+    // Power Management
+    async sleep() {
+        return execPromise('systemctl suspend');
+    },
+
+    async restart() {
+        return execPromise('systemctl reboot');
+    },
+
+    async shutdown() {
+        return execPromise('systemctl poweroff');
+    },
+
+    // Window Management (Minimal implementation using xdotool if available)
+    async minimizeAll() {
+        try {
+            await execPromise('xdotool key Super+d');
+            return "Minimized all windows";
+        } catch (e) {
+            throw new Error("xdotool not found. Cannot perform window management.");
+        }
+    }
+};
+
+module.exports = SystemAutomation;

package/src/System/system_events.js

@@ -0,0 +1,79 @@
+const { exec } = require('child_process');
+const EventEmitter = require('events');
+
+class SystemEvents extends EventEmitter {
+    constructor() {
+        super();
+        this.lastBatteryLevel = null;
+        this.lastConnectionStatus = null;
+        this.checkInterval = 60000; // 1 minute
+        this.isMonitoring = false;
+    }
+
+    startMonitoring() {
+        if (this.isMonitoring) return;
+        this.isMonitoring = true;
+        this.check();
+        this.timer = setInterval(() => this.check(), this.checkInterval);
+    }
+
+    stopMonitoring() {
+        if (this.timer) clearInterval(this.timer);
+        this.isMonitoring = false;
+    }
+
+    async check() {
+        await this.checkBattery();
+        await this.checkNetwork();
+    }
+
+    async checkBattery() {
+        try {
+            // Linux: upower -i $(upower -e | grep 'BAT') | grep -E "percentage"
+            const cmd = "upower -i $(upower -e | grep 'BAT') | grep -E 'percentage' | awk '{print $2}' | tr -d '%'";
+            const output = await this.execPromise(cmd);
+            const level = parseInt(output);
+            
+            if (isNaN(level)) return;
+
+            // Notify if battery is low (below 20%) and has dropped
+            if (level <= 20 && (this.lastBatteryLevel === null || this.lastBatteryLevel > 20)) {
+                this.emit('low-battery', level);
+            }
+            
+            this.lastBatteryLevel = level;
+        } catch (err) {
+            // Ignore if upower fails (e.g. desktop)
+        }
+    }
+
+    async checkNetwork() {
+        try {
+            // Check internet connection
+            const online = await this.execPromise("ping -c 1 8.8.8.8 > /dev/null && echo 'online' || echo 'offline'");
+            const isOnline = online === 'online';
+
+            if (this.lastConnectionStatus !== null && this.lastConnectionStatus !== isOnline) {
+                this.emit('connection-change', isOnline);
+            }
+
+            this.lastConnectionStatus = isOnline;
+        } catch (err) {
+            // Ignore ping errors
+        }
+    }
+
+    execPromise(command) {
+        return new Promise((resolve) => {
+            exec(command, (error, stdout) => {
+                if (error) {
+                    resolve('');
+                    return;
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+}
+
+module.exports = new SystemEvents();

package/src/System/system_info.js

@@ -0,0 +1,55 @@
+const os = require('os');
+
+/**
+ * ดึงข้อมูล RAM, CPU, เวลาปัจจุบัน
+ */
+function getSystemInfo() {
+    const totalRAM = os.totalmem();
+    const freeRAM = os.freemem();
+    const usedRAM = totalRAM - freeRAM;
+    const ramPercent = ((usedRAM / totalRAM) * 100).toFixed(1);
+
+    const now = new Date();
+    const timeStr = now.toLocaleTimeString('th-TH', { hour: '2-digit', minute: '2-digit' });
+    const dateStr = now.toLocaleDateString('th-TH', { year: 'numeric', month: 'long', day: 'numeric' });
+
+    const cpuModel = os.cpus()[0]?.model || 'Unknown CPU';
+    const cpuCores = os.cpus().length;
+    const platform = os.platform();
+    const hostname = os.hostname();
+
+    return {
+        ram: {
+            total: (totalRAM / 1024 / 1024 / 1024).toFixed(2) + ' GB',
+            used: (usedRAM / 1024 / 1024 / 1024).toFixed(2) + ' GB',
+            free: (freeRAM / 1024 / 1024 / 1024).toFixed(2) + ' GB',
+            percent: ramPercent + '%'
+        },
+        cpu: {
+            model: cpuModel,
+            cores: cpuCores
+        },
+        time: timeStr,
+        date: dateStr,
+        platform,
+        hostname
+    };
+}
+
+/**
+ * ดึงข้อมูลอากาศจาก wttr.in (ไม่ต้อง API key)
+ * @param {string} city - ชื่อเมือง เช่น Bangkok
+ */
+async function getWeather(city = 'Bangkok') {
+    try {
+        const response = await fetch(`https://wttr.in/${encodeURIComponent(city)}?format=3&lang=th`);
+        if (!response.ok) throw new Error('Weather fetch failed');
+        const text = await response.text();
+        return { success: true, data: text.trim() };
+    } catch (err) {
+        console.error('getWeather error:', err);
+        return { success: false, data: 'ไม่สามารถดึงข้อมูลอากาศได้ในขณะนี้' };
+    }
+}
+
+module.exports = { getSystemInfo, getWeather };

package/src/System/task_manager.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Standard location for Mint tasks
+const MINT_DIR = path.join(os.homedir(), '.mint');
+const TASKS_FILE = path.join(MINT_DIR, 'tasks.json');
+
+// Ensure directory exists
+if (!fs.existsSync(MINT_DIR)) {
+    fs.mkdirSync(MINT_DIR, { recursive: true });
+}
+
+/**
+ * Task Statuses:
+ * - 'pending': Waiting for agent to pick up
+ * - 'running': Agent is currently working on it
+ * - 'completed': Done
+ * - 'failed': Error occurred
+ */
+
+function readTasks() {
+    if (!fs.existsSync(TASKS_FILE)) return [];
+    try {
+        const content = fs.readFileSync(TASKS_FILE, 'utf8');
+        return JSON.parse(content);
+    } catch (e) {
+        console.error('[TaskManager] Error reading tasks:', e.message);
+        return [];
+    }
+}
+
+function writeTasks(tasks) {
+    try {
+        fs.writeFileSync(TASKS_FILE, JSON.stringify(tasks, null, 2));
+    } catch (e) {
+        console.error('[TaskManager] Error writing tasks:', e.message);
+    }
+}
+
+function addTask(description) {
+    const tasks = readTasks();
+    const newTask = {
+        id: Date.now().toString(),
+        description,
+        status: 'pending',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        steps: [],
+        result: null
+    };
+    tasks.push(newTask);
+    writeTasks(tasks);
+    return newTask;
+}
+
+function getPendingTask() {
+    const tasks = readTasks();
+    return tasks.find(t => t.status === 'pending');
+}
+
+function updateTask(id, updates) {
+    const tasks = readTasks();
+    const idx = tasks.findIndex(t => t.id === id);
+    if (idx !== -1) {
+        tasks[idx] = { ...tasks[idx], ...updates, updatedAt: new Date().toISOString() };
+        writeTasks(tasks);
+        return tasks[idx];
+    }
+    return null;
+}
+
+function clearCompletedTasks() {
+    const tasks = readTasks();
+    const activeTasks = tasks.filter(t => t.status === 'pending' || t.status === 'running');
+    writeTasks(activeTasks);
+}
+
+module.exports = {
+    addTask,
+    getPendingTask,
+    updateTask,
+    readTasks,
+    clearCompletedTasks
+};

package/src/UI/floating.css

@@ -0,0 +1,80 @@
+:root {
+    --badge: #ff4d6d;
+    --badge-border: rgba(0, 0, 0, 0.5);
+    --ring: rgba(139, 92, 246, 0.5);
+}
+
+* {
+    box-sizing: border-box;
+}
+
+body {
+    margin: 0;
+    width: 100vw;
+    height: 100vh;
+    background: transparent;
+    display: grid;
+    overflow: hidden;
+    place-items: center;
+    -webkit-app-region: drag;
+    font-family: system-ui, sans-serif;
+}
+
+body.dragging {
+    cursor: grabbing;
+}
+
+#floating-btn {
+    width: 64px;
+    height: 64px;
+    border: 0;
+    border-radius: 50%;
+    background: rgba(20, 16, 32, 0.85);
+    box-shadow: 0 10px 24px rgba(0, 0, 0, 0.35), 0 0 0 2px rgba(255, 255, 255, 0.05) inset;
+    display: grid;
+    place-items: center;
+    position: relative;
+    cursor: pointer;
+    -webkit-app-region: no-drag;
+    transition: transform 120ms ease, box-shadow 120ms ease;
+}
+
+#floating-btn:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 14px 28px rgba(0, 0, 0, 0.4), 0 0 0 2px rgba(255, 255, 255, 0.08) inset;
+}
+
+#floating-btn img {
+    width: 36px;
+    height: 36px;
+    -webkit-user-drag: none;
+    user-select: none;
+}
+
+.badge {
+    position: absolute;
+    top: -4px;
+    right: -4px;
+    min-width: 20px;
+    height: 20px;
+    padding: 0 6px;
+    border-radius: 999px;
+    background: var(--badge);
+    color: white;
+    font-size: 12px;
+    line-height: 20px;
+    text-align: center;
+    border: 2px solid var(--badge-border);
+    display: none;
+}
+
+body.has-unread #floating-btn {
+    box-shadow: 0 0 0 3px var(--ring), 0 10px 24px rgba(0, 0, 0, 0.35), 0 0 0 2px rgba(255, 255, 255, 0.05) inset;
+    animation: pulse 1.6s ease-in-out infinite;
+}
+
+@keyframes pulse {
+    0% { transform: scale(1); }
+    50% { transform: scale(1.03); }
+    100% { transform: scale(1); }
+}

package/src/UI/floating.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self';">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Mint Floating</title>
+    <link rel="stylesheet" href="floating.css" />
+</head>
+<body>
+    <button id="floating-btn" aria-label="Open Mint">
+        <img src="../../assets/icon.png" alt="Mint" draggable="false" />
+        <span id="badge" class="badge" aria-hidden="true">1</span>
+    </button>
+    <script src="floating.js"></script>
+</body>
+</html>

package/src/UI/floating.js

@@ -0,0 +1,67 @@
+const floatingBtn = document.getElementById('floating-btn');
+const badge = document.getElementById('badge');
+let isDragging = false;
+let didDrag = false;
+let dragStart = null;
+
+function startDrag() {
+    isDragging = true;
+    document.body.classList.add('dragging');
+}
+
+function stopDrag() {
+    isDragging = false;
+    document.body.classList.remove('dragging');
+}
+
+function setBadge(count) {
+    const value = Number(count) || 0;
+    if (value <= 0) {
+        badge.style.display = 'none';
+        document.body.classList.remove('has-unread');
+        return;
+    }
+    badge.textContent = value > 9 ? '9+' : String(value);
+    badge.style.display = 'inline-block';
+    document.body.classList.add('has-unread');
+}
+
+floatingBtn.addEventListener('click', () => {
+    if (didDrag) return;
+    if (window.floating) window.floating.openMain();
+});
+
+if (window.floating) {
+    window.floating.onNotify((count) => {
+        setBadge(count);
+    });
+}
+
+window.addEventListener('mousedown', (e) => {
+    if (e.button !== 0) return;
+    e.preventDefault();
+    startDrag();
+    didDrag = false;
+    dragStart = { x: e.screenX, y: e.screenY };
+});
+
+window.addEventListener('mousemove', (e) => {
+    if (!isDragging) return;
+    if (dragStart) {
+        const dx = e.screenX - dragStart.x;
+        const dy = e.screenY - dragStart.y;
+        if (!didDrag && Math.hypot(dx, dy) < 4) return;
+        didDrag = true;
+    }
+    if (window.floating) window.floating.dragMove(e.screenX, e.screenY);
+});
+
+window.addEventListener('mouseup', () => {
+    stopDrag();
+    dragStart = null;
+});
+
+window.addEventListener('mouseleave', () => {
+    stopDrag();
+    dragStart = null;
+});