@pheem49/mint 1.4.2 → 1.5.1

package/src/System/system_automation.js

@@ -1,115 +1,161 @@
-const { exec } = require('child_process');
+const { execFile } = require('child_process');
+const fs = require('fs');
 
-/**
- * Executes a shell command and returns a promise.
- */
-function execPromise(command) {
+function execPromise(command, args = []) {
     return new Promise((resolve, reject) => {
-        exec(command, (error, stdout, stderr) => {
+        execFile(command, args, (error, stdout, stderr) => {
             if (error) {
+                error.stderr = stderr;
                 reject(error);
                 return;
             }
-            resolve(stdout.trim());
+            resolve(String(stdout || '').trim());
         });
     });
 }
 
-/**
- * Linux System Automation Logic
- */
-const SystemAutomation = {
-    // Volume Control (Using amixer / pulseaudio)
+function unsupported(feature) {
+    throw new Error(`${feature} is not supported on ${process.platform} by the current automation provider.`);
+}
+
+function clampPercent(percent) {
+    const value = Number(percent);
+    if (!Number.isFinite(value)) return 50;
+    return Math.max(0, Math.min(100, Math.round(value)));
+}
+
+const linuxProvider = {
     async setVolume(percent) {
-        // Try amixer first (common on many distros)
+        const value = clampPercent(percent);
         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.");
-            }
+            await execPromise('amixer', ['-D', 'pulse', 'sset', 'Master', `${value}%`]);
+            return `Volume set to ${value}%`;
+        } catch (_) {
+            await execPromise('pactl', ['set-sink-volume', '@DEFAULT_SINK@', `${value}%`]);
+            return `Volume set to ${value}%`;
         }
     },
-
     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)";
+            await execPromise('amixer', ['-D', 'pulse', 'sset', 'Master', 'toggle']);
+            return 'Volume toggled (mute/unmute)';
+        } catch (_) {
+            await execPromise('pactl', ['set-sink-mute', '@DEFAULT_SINK@', 'toggle']);
+            return 'Volume toggled (mute/unmute)';
         }
     },
-
-    // Brightness Control (Using brightnessctl or xbacklight)
     async setBrightness(percent) {
+        const value = clampPercent(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.");
-            }
+            await execPromise('brightnessctl', ['set', `${value}%`]);
+            return `Brightness set to ${value}%`;
+        } catch (_) {
+            await execPromise('xbacklight', ['-set', String(value)]);
+            return `Brightness set to ${value}%`;
         }
     },
-
-    // Power Management
-    async sleep() {
-        return execPromise('systemctl suspend');
+    sleep: () => execPromise('systemctl', ['suspend']),
+    restart: () => execPromise('systemctl', ['reboot']),
+    shutdown: () => execPromise('systemctl', ['poweroff']),
+    async minimizeAll() {
+        await execPromise('xdotool', ['key', 'Super+d']);
+        return 'Minimized all windows';
     },
+    async getSystemInfo() {
+        try {
+            const osInfo = await execPromise('lsb_release', ['-ds']);
+            const kernel = await execPromise('uname', ['-r']);
+            const arch = await execPromise('uname', ['-m']);
+            return `Operating System: ${osInfo}\nKernel: ${kernel}\nArchitecture: ${arch}`;
+        } catch (_) {
+            const osRelease = fs.existsSync('/etc/os-release') ? fs.readFileSync('/etc/os-release', 'utf8') : '';
+            const prettyName = (osRelease.match(/^PRETTY_NAME="?([^"\n]+)"?/m) || [])[1] || 'Linux';
+            const kernel = await execPromise('uname', ['-r']);
+            const arch = await execPromise('uname', ['-m']);
+            return `Operating System: ${prettyName}\nKernel: ${kernel}\nArchitecture: ${arch}`;
+        }
+    }
+};
 
-    async restart() {
-        return execPromise('systemctl reboot');
+const macProvider = {
+    async setVolume(percent) {
+        const value = clampPercent(percent);
+        await execPromise('osascript', ['-e', `set volume output volume ${value}`]);
+        return `Volume set to ${value}%`;
     },
-
-    async shutdown() {
-        return execPromise('systemctl poweroff');
+    async mute() {
+        await execPromise('osascript', ['-e', 'set volume output muted not (output muted of (get volume settings))']);
+        return 'Volume toggled (mute/unmute)';
+    },
+    setBrightness: () => unsupported('Brightness control'),
+    sleep: () => execPromise('osascript', ['-e', 'tell application "System Events" to sleep']),
+    restart: () => execPromise('osascript', ['-e', 'tell application "System Events" to restart']),
+    shutdown: () => execPromise('osascript', ['-e', 'tell application "System Events" to shut down']),
+    async minimizeAll() {
+        await execPromise('osascript', ['-e', 'tell application "System Events" to keystroke "h" using {command down, option down}']);
+        return 'Hid visible applications';
     },
+    async getSystemInfo() {
+        const product = await execPromise('sw_vers', ['-productName']);
+        const version = await execPromise('sw_vers', ['-productVersion']);
+        const build = await execPromise('sw_vers', ['-buildVersion']);
+        const arch = await execPromise('uname', ['-m']);
+        return `Operating System: ${product} ${version} (${build})\nArchitecture: ${arch}`;
+    }
+};
 
-    // Window Management (Minimal implementation using xdotool if available)
+const windowsProvider = {
+    setVolume: () => unsupported('Volume control'),
+    mute: () => unsupported('Mute control'),
+    setBrightness: () => unsupported('Brightness control'),
+    sleep: () => execPromise('rundll32.exe', ['powrprof.dll,SetSuspendState', '0,1,0']),
+    restart: () => execPromise('shutdown.exe', ['/r', '/t', '0']),
+    shutdown: () => execPromise('shutdown.exe', ['/s', '/t', '0']),
     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.");
-        }
+        await execPromise('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            '$shell = New-Object -ComObject Shell.Application; $shell.MinimizeAll()'
+        ]);
+        return 'Minimized all windows';
     },
+    async getSystemInfo() {
+        const caption = await execPromise('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            '(Get-CimInstance Win32_OperatingSystem).Caption'
+        ]);
+        const version = await execPromise('cmd.exe', ['/c', 'ver']);
+        const arch = process.arch;
+        return `Operating System: ${caption}\nVersion: ${version}\nArchitecture: ${arch}`;
+    }
+};
 
-    // System Information
-    async getSystemInfo(target = "") {
-        // If target is empty, return OS info
-        if (!target) {
-            try {
-                // Try lsb_release first
-                const osInfo = await execPromise('lsb_release -ds');
-                const kernel = await execPromise('uname -r');
-                const arch = await execPromise('uname -m');
-                return `Operating System: ${osInfo}\nKernel: ${kernel}\nArchitecture: ${arch}`;
-            } catch (e) {
-                try {
-                    // Fallback to /etc/os-release
-                    const osInfo = await execPromise('grep PRETTY_NAME /etc/os-release | cut -d\'"\' -f2');
-                    const kernel = await execPromise('uname -r');
-                    const arch = await execPromise('uname -m');
-                    return `Operating System: ${osInfo}\nKernel: ${kernel}\nArchitecture: ${arch}`;
-                } catch (err) {
-                    return "Could not retrieve OS information.";
-                }
-            }
-        }
-        
-        // Handle weather or other info if target is provided
-        // For now, let's just return a placeholder or handle it if needed
+function getProvider(platform = process.platform) {
+    if (platform === 'darwin') return macProvider;
+    if (platform === 'win32') return windowsProvider;
+    return linuxProvider;
+}
+
+const SystemAutomation = {
+    setVolume: (percent) => getProvider().setVolume(percent),
+    mute: () => getProvider().mute(),
+    setBrightness: (percent) => getProvider().setBrightness(percent),
+    sleep: () => getProvider().sleep(),
+    restart: () => getProvider().restart(),
+    shutdown: () => getProvider().shutdown(),
+    minimizeAll: () => getProvider().minimizeAll(),
+    async getSystemInfo(target = '') {
+        if (!target) return getProvider().getSystemInfo();
         return `System info for ${target} is not yet implemented.`;
+    },
+    _providers: {
+        linux: linuxProvider,
+        darwin: macProvider,
+        win32: windowsProvider,
+        getProvider
     }
 };
 

package/src/System/system_info.js

@@ -1,4 +1,70 @@
 const os = require('os');
+const fs = require('fs');
+
+function readFirstExisting(paths) {
+    for (const filePath of paths) {
+        try {
+            const value = fs.readFileSync(filePath, 'utf8').trim();
+            if (value && value !== 'None' && value !== 'To be filled by O.E.M.') {
+                return value;
+            }
+        } catch (_) {}
+    }
+    return '';
+}
+
+function getLinuxDistro() {
+    try {
+        const content = fs.readFileSync('/etc/os-release', 'utf8');
+        const values = {};
+        content.split('\n').forEach(line => {
+            const match = line.match(/^([A-Z_]+)=(.*)$/);
+            if (match) {
+                values[match[1]] = match[2].replace(/^"|"$/g, '');
+            }
+        });
+        return values.PRETTY_NAME || values.NAME || '';
+    } catch (_) {
+        return '';
+    }
+}
+
+function getMachineModel() {
+    if (os.platform() !== 'linux') {
+        return {
+            vendor: '',
+            product: os.hostname(),
+            version: '',
+            board: '',
+            display: os.hostname()
+        };
+    }
+
+    const vendor = readFirstExisting([
+        '/sys/devices/virtual/dmi/id/sys_vendor',
+        '/sys/class/dmi/id/sys_vendor'
+    ]);
+    const product = readFirstExisting([
+        '/sys/devices/virtual/dmi/id/product_name',
+        '/sys/class/dmi/id/product_name'
+    ]);
+    const version = readFirstExisting([
+        '/sys/devices/virtual/dmi/id/product_version',
+        '/sys/class/dmi/id/product_version'
+    ]);
+    const board = readFirstExisting([
+        '/sys/devices/virtual/dmi/id/board_name',
+        '/sys/class/dmi/id/board_name'
+    ]);
+
+    return {
+        vendor,
+        product,
+        version,
+        board,
+        display: [vendor, product, version].filter(Boolean).join(' ') || board || os.hostname()
+    };
+}
 
 /**
  * ดึงข้อมูล RAM, CPU, เวลาปัจจุบัน
@@ -16,9 +82,12 @@ function getSystemInfo() {
     const cpuModel = os.cpus()[0]?.model || 'Unknown CPU';
     const cpuCores = os.cpus().length;
     const platform = os.platform();
+    const distro = platform === 'linux' ? getLinuxDistro() : '';
     const hostname = os.hostname();
+    const machine = getMachineModel();
 
     return {
+        machine,
         ram: {
             total: (totalRAM / 1024 / 1024 / 1024).toFixed(2) + ' GB',
             used: (usedRAM / 1024 / 1024 / 1024).toFixed(2) + ' GB',
@@ -32,6 +101,7 @@ function getSystemInfo() {
         time: timeStr,
         date: dateStr,
         platform,
+        distro,
         hostname
     };
 }

package/src/System/task_manager.js

@@ -2,13 +2,23 @@ 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');
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'mint');
+const TASKS_FILE = path.join(CONFIG_DIR, 'tasks.json');
 
 // Ensure directory exists
-if (!fs.existsSync(MINT_DIR)) {
-    fs.mkdirSync(MINT_DIR, { recursive: true });
+if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+// Migration Logic: Move tasks.json from ~/.mint to ~/.config/mint
+if (!fs.existsSync(TASKS_FILE)) {
+    const legacyPath = path.join(os.homedir(), '.mint', 'tasks.json');
+    if (fs.existsSync(legacyPath)) {
+        try {
+            fs.copyFileSync(legacyPath, TASKS_FILE);
+            console.log('[TaskManager] Migrated tasks from ~/.mint');
+        } catch (e) { console.error('[TaskManager] Migration failed:', e); }
+    }
 }
 
 /**

package/src/System/tool_registry.js

@@ -0,0 +1,280 @@
+const TOOL_REGISTRY = Object.freeze({
+    none: {
+        permission: 'safe',
+        required: [],
+        description: 'No action.'
+    },
+    web_search: {
+        permission: 'safe',
+        required: ['query'],
+        codeAgentOnly: true,
+        description: 'Search the internet when outside knowledge is required.'
+    },
+    list_files: {
+        permission: 'safe',
+        required: [],
+        codeAgentOnly: true,
+        description: 'List files under a workspace-relative path.'
+    },
+    read_file: {
+        permission: 'safe',
+        required: ['path'],
+        codeAgentOnly: true,
+        description: 'Read a workspace file, optionally bounded by startLine/endLine.'
+    },
+    search_code: {
+        permission: 'safe',
+        required: ['query'],
+        codeAgentOnly: true,
+        description: 'Search text in the workspace.'
+    },
+    find_path: {
+        permission: 'safe',
+        required: ['query'],
+        chatAction: true,
+        description: 'Find files or folders by name.'
+    },
+    run_shell: {
+        permission: 'approval',
+        required: ['command'],
+        codeAgentOnly: true,
+        important: true,
+        description: 'Run a non-destructive shell command after user approval.'
+    },
+    apply_patch: {
+        permission: 'approval',
+        required: ['patch'],
+        codeAgentOnly: true,
+        important: true,
+        description: 'Patch an existing file after user approval.'
+    },
+    write_file: {
+        permission: 'approval',
+        required: ['path', 'content'],
+        codeAgentOnly: true,
+        important: true,
+        description: 'Create or replace a file after user approval.'
+    },
+    ask_user: {
+        permission: 'safe',
+        required: ['question'],
+        codeAgentOnly: true,
+        description: 'Ask the user for clarification.'
+    },
+    open_url: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Open a URL.'
+    },
+    search: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Open a web search.'
+    },
+    open_app: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Open a local application.'
+    },
+    web_automation: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        important: true,
+        description: 'Perform browser automation.'
+    },
+    create_folder: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Create a folder.'
+    },
+    open_file: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Open a local file.'
+    },
+    open_folder: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Open a local folder.'
+    },
+    delete_file: {
+        permission: 'dangerous',
+        required: ['target'],
+        chatAction: true,
+        important: true,
+        description: 'Delete a file only after explicit dangerous-action permission.'
+    },
+    clipboard_write: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Write text to clipboard.'
+    },
+    learn_file: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Index a file into the knowledge base.'
+    },
+    learn_folder: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        description: 'Index a folder into the knowledge base.'
+    },
+    system_info: {
+        permission: 'safe',
+        required: [],
+        chatAction: true,
+        description: 'Read local system info, or weather when target is a city.'
+    },
+    plugin: {
+        permission: 'safe',
+        required: ['pluginName', 'target'],
+        chatAction: true,
+        description: 'Run a Mint plugin.'
+    },
+    mcp_tool: {
+        permission: 'safe',
+        required: ['server', 'target'],
+        chatAction: true,
+        description: 'Call an MCP tool.'
+    },
+    mouse_click: {
+        permission: 'safe',
+        required: ['x', 'y'],
+        chatAction: true,
+        important: true,
+        description: 'Click at screen coordinates.'
+    },
+    mouse_move: {
+        permission: 'safe',
+        required: ['x', 'y'],
+        chatAction: true,
+        description: 'Move the mouse.'
+    },
+    type_text: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        important: true,
+        description: 'Type text into the active UI.'
+    },
+    key_tap: {
+        permission: 'safe',
+        required: ['target'],
+        chatAction: true,
+        important: true,
+        description: 'Press a key.'
+    },
+    system_automation: {
+        permission: 'approval',
+        required: ['target'],
+        chatAction: true,
+        important: true,
+        description: 'Change system settings after approval.'
+    },
+    finish: {
+        permission: 'safe',
+        required: ['summary'],
+        codeAgentOnly: true,
+        description: 'Finish the task and reply.'
+    }
+});
+
+function getTool(name) {
+    return TOOL_REGISTRY[name] || null;
+}
+
+function listToolNames(filter = {}) {
+    return Object.entries(TOOL_REGISTRY)
+        .filter(([, tool]) => {
+            if (filter.chatAction === true && tool.chatAction !== true) return false;
+            if (filter.codeAgent === true && tool.chatAction === true && tool.codeAgentOnly !== true) return true;
+            return true;
+        })
+        .map(([name]) => name);
+}
+
+function listChatActionNames() {
+    return Object.entries(TOOL_REGISTRY)
+        .filter(([, tool]) => tool.chatAction === true)
+        .map(([name]) => name);
+}
+
+function listCodeAgentActionNames() {
+    return Object.entries(TOOL_REGISTRY)
+        .filter(([, tool]) => tool.codeAgentOnly === true || tool.chatAction === true || tool.required)
+        .map(([name]) => name);
+}
+
+function isEmptyToolValue(value) {
+    if (value === undefined || value === null) return true;
+    if (typeof value === 'string') return value.trim() === '';
+    if (Array.isArray(value)) return value.length === 0;
+    if (typeof value === 'object') return Object.keys(value).length === 0;
+    return false;
+}
+
+function validateToolInput(action, input = {}) {
+    const tool = getTool(action);
+    if (!tool) {
+        throw new Error(`Unsupported action: ${action}`);
+    }
+
+    const missing = (tool.required || []).filter(field => {
+        if (!isEmptyToolValue(input[field])) return false;
+        if (field === 'target' && (!isEmptyToolValue(input.path) || !isEmptyToolValue(input.query))) return false;
+        if (field === 'query' && !isEmptyToolValue(input.target)) return false;
+        return true;
+    });
+    if (missing.length > 0) {
+        throw new Error(`Action "${action}" is missing required input field(s): ${missing.join(', ')}`);
+    }
+
+    if (action === 'apply_patch') {
+        const patchInput = input.patch || {};
+        if (!patchInput.path || !Array.isArray(patchInput.hunks) || patchInput.hunks.length === 0) {
+            throw new Error('Action "apply_patch" requires input.patch.path and at least one hunk.');
+        }
+    }
+
+    return tool;
+}
+
+function isImportantAction(action) {
+    const tool = getTool(action);
+    return !!(tool && tool.important);
+}
+
+function buildChatActionTypeUnion() {
+    return ['none', ...listChatActionNames()].filter((name, index, arr) => arr.indexOf(name) === index).map(name => `"${name}"`).join(' | ');
+}
+
+function buildToolPromptSection() {
+    const lines = ['\n\nAVAILABLE BUILT-IN ACTIONS:'];
+    for (const name of listChatActionNames()) {
+        const tool = getTool(name);
+        lines.push(`- ${name}: ${tool.description}`);
+    }
+    return lines.join('\n');
+}
+
+module.exports = {
+    TOOL_REGISTRY,
+    getTool,
+    listToolNames,
+    listChatActionNames,
+    listCodeAgentActionNames,
+    validateToolInput,
+    isImportantAction,
+    buildChatActionTypeUnion,
+    buildToolPromptSection
+};