@pheem49/mint 1.5.0 → 1.5.1

package/src/System/sandbox_runner.js

@@ -0,0 +1,182 @@
+const { execFile, spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const safetyManager = require('./safety_manager');
+
+function commandExists(command) {
+    const lookup = process.platform === 'win32' ? 'where' : 'which';
+    const result = spawnSync(lookup, [command], { encoding: 'utf8', shell: false });
+    return result.status === 0;
+}
+
+function uniqueExistingRoots(roots) {
+    return Array.from(new Set((roots || [])
+        .filter(Boolean)
+        .map((root) => path.resolve(root))
+        .filter((root) => fs.existsSync(root))));
+}
+
+function buildBubblewrapArgs(command, options = {}) {
+    const cwd = path.resolve(options.cwd || process.cwd());
+    const readRoots = uniqueExistingRoots(safetyManager.getAllowedRoots('read'));
+    const writeRoots = uniqueExistingRoots(safetyManager.getAllowedRoots('write'));
+    const writableSet = new Set(writeRoots);
+    const bindRoots = uniqueExistingRoots([cwd, ...readRoots, ...writeRoots]);
+
+    const args = [
+        '--die-with-parent',
+        '--proc', '/proc',
+        '--dev', '/dev',
+        '--tmpfs', '/tmp',
+        '--ro-bind', '/usr', '/usr',
+        '--ro-bind', '/bin', '/bin',
+        '--ro-bind', '/etc', '/etc'
+    ];
+
+    for (const libPath of ['/lib', '/lib64']) {
+        if (fs.existsSync(libPath)) args.push('--ro-bind', libPath, libPath);
+    }
+
+    const parentDirs = new Set();
+    for (const root of bindRoots) {
+        let current = path.dirname(root);
+        while (current && current !== path.dirname(current)) {
+            parentDirs.add(current);
+            current = path.dirname(current);
+        }
+    }
+    for (const dir of Array.from(parentDirs).sort((a, b) => a.length - b.length)) {
+        if (!['/usr', '/bin', '/etc', '/lib', '/lib64'].includes(dir)) {
+            args.push('--dir', dir);
+        }
+    }
+
+    for (const root of bindRoots) {
+        const flag = writableSet.has(root) || root === cwd ? '--bind' : '--ro-bind';
+        args.push(flag, root, root);
+    }
+
+    args.push('--chdir', cwd, 'bash', '-lc', command);
+    return args;
+}
+
+function escapeSandboxProfileString(value) {
+    return String(value || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function buildMacSandboxProfile(options = {}) {
+    const cwd = path.resolve(options.cwd || process.cwd());
+    const readRoots = uniqueExistingRoots(safetyManager.getAllowedRoots('read'));
+    const writeRoots = uniqueExistingRoots(safetyManager.getAllowedRoots('write'));
+    const allowedRead = uniqueExistingRoots([
+        cwd,
+        '/bin',
+        '/sbin',
+        '/usr',
+        '/System',
+        '/Library',
+        ...readRoots,
+        ...writeRoots
+    ]);
+    const allowedWrite = uniqueExistingRoots([cwd, ...writeRoots]);
+
+    const readRules = allowedRead.map((root) => `  (subpath "${escapeSandboxProfileString(root)}")`).join('\n');
+    const writeRules = allowedWrite.map((root) => `  (subpath "${escapeSandboxProfileString(root)}")`).join('\n');
+
+    return [
+        '(version 1)',
+        '(deny default)',
+        '(allow process*)',
+        '(allow sysctl-read)',
+        '(allow signal (target self))',
+        '(allow file-read-metadata)',
+        '(allow file-read*',
+        readRules,
+        ')',
+        '(allow file-write*',
+        writeRules,
+        `  (subpath "${escapeSandboxProfileString(os.tmpdir())}")`,
+        ')'
+    ].join('\n');
+}
+
+function getShellInvocation(command) {
+    if (process.platform === 'win32') {
+        return {
+            command: 'powershell.exe',
+            args: ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', command]
+        };
+    }
+    return {
+        command: 'bash',
+        args: ['-lc', command]
+    };
+}
+
+function execFilePromise(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        execFile(command, args, options, (error, stdout, stderr) => {
+            if (error) {
+                error.stdout = stdout;
+                error.stderr = stderr;
+                reject(error);
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
+
+async function runShell(command, options = {}) {
+    const policy = safetyManager.getPolicy();
+    safetyManager.assertShellCommandAllowed(command);
+
+    const cwd = path.resolve(options.cwd || process.cwd());
+    const execOptions = {
+        cwd,
+        maxBuffer: options.maxBuffer || 1024 * 1024 * 4,
+        env: options.env || process.env
+    };
+
+    if (!policy.enabled || policy.sandboxMode === 'off') {
+        const shell = getShellInvocation(command);
+        return execFilePromise(shell.command, shell.args, execOptions);
+    }
+
+    const sandboxCommand = policy.sandboxCommand || 'bwrap';
+    if (process.platform === 'linux' && commandExists(sandboxCommand)) {
+        return execFilePromise(sandboxCommand, buildBubblewrapArgs(command, { cwd }), execOptions);
+    }
+
+    if (process.platform === 'darwin' && commandExists('sandbox-exec')) {
+        return execFilePromise('sandbox-exec', ['-p', buildMacSandboxProfile({ cwd }), 'bash', '-lc', command], execOptions);
+    }
+
+    if (policy.sandboxMode === 'enforce') {
+        const hint = process.platform === 'darwin'
+            ? "macOS sandbox-exec is not available."
+            : process.platform === 'win32'
+                ? 'Windows sandbox provider is not configured. Use WSL/containers or set sandboxMode to prefer.'
+                : `Sandbox command '${sandboxCommand}' is not available.`;
+        throw new Error(`Sandbox is enforced but no sandbox provider could run. ${hint}`);
+    }
+
+    safetyManager.appendActionLog({
+        source: options.source || 'sandbox_runner',
+        action: 'sandbox_fallback',
+        sandboxCommand,
+        platform: process.platform,
+        cwd
+    });
+    const shell = getShellInvocation(command);
+    return execFilePromise(shell.command, shell.args, execOptions);
+}
+
+module.exports = {
+    runShell,
+    buildBubblewrapArgs,
+    buildMacSandboxProfile,
+    getShellInvocation,
+    commandExists
+};

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
     };
 }