ft-scout 7.0.4 → 7.0.6

package/bin/src/engine/appControl.js

@@ -0,0 +1,660 @@
+import fs from 'fs';
+import path from 'path';
+import http from 'http';
+import https from 'https';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Standardize app name aliases across platforms.
+ */
+export function normalizeAppName(rawAppName) {
+    const appLower = (rawAppName || '').trim().toLowerCase();
+    if (['browser', 'chrome', 'google-chrome', 'msedge', 'edge', 'firefox', 'brave', 'safari', 'opera', 'instagram', 'whatsapp', 'twitter', 'x', 'telegram', 'linkedin', 'slack', 'discord'].includes(appLower)) {
+        return { category: 'browser', name: appLower || 'browser' };
+    }
+    if (['terminal', 'cmd', 'powershell', 'pwsh', 'wt', 'windows-terminal', 'iterm', 'bash', 'zsh', 'sh', 'console', 'konsole'].includes(appLower)) {
+        return { category: 'terminal', name: appLower || 'terminal' };
+    }
+    if (['code', 'vscode', 'visual-studio-code', 'cursor', 'zed', 'sublime', 'notepad', 'notepad++', 'vim', 'nvim', 'nano', 'editor'].includes(appLower)) {
+        return { category: 'editor', name: appLower || 'editor' };
+    }
+    return { category: 'system', name: appLower };
+}
+export function parsePayload(payload) {
+    if (!payload)
+        return {};
+    if (typeof payload === 'object')
+        return payload;
+    if (typeof payload === 'string') {
+        const trimmed = payload.trim();
+        if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch { }
+        }
+    }
+    return { target: payload };
+}
+export function buildSocialUrl(platformOrAppName, target, text) {
+    const parsedPayload = parsePayload(target);
+    const rawTarget = typeof target === 'string' && !target.trim().startsWith('{')
+        ? target.trim()
+        : (parsedPayload.recipient || parsedPayload.user || parsedPayload.username || parsedPayload.handle || parsedPayload.target || parsedPayload.url || '');
+    const rawMsgText = text || parsedPayload.text || parsedPayload.message || parsedPayload.content || '';
+    const pLower = (platformOrAppName || parsedPayload.platform || '').toLowerCase().trim();
+    const cleanTarget = String(rawTarget || '').trim();
+    const handleMatch = cleanTarget.match(/@?([a-zA-Z0-9_.-]+)/);
+    const handle = handleMatch && handleMatch[1] ? handleMatch[1] : '';
+    const isInstagram = pLower.includes('instagram') || cleanTarget.includes('instagram') || cleanTarget.startsWith('@');
+    const isWhatsApp = pLower.includes('whatsapp') || cleanTarget.includes('whatsapp') || (/^\+?[0-9]{7,15}$/.test(cleanTarget) && !cleanTarget.startsWith('http'));
+    const isTwitter = pLower.includes('twitter') || pLower.includes('x') || cleanTarget.includes('x.com') || cleanTarget.includes('twitter.com');
+    const isTelegram = pLower.includes('telegram') || cleanTarget.includes('t.me');
+    const isLinkedIn = pLower.includes('linkedin') || cleanTarget.includes('linkedin.com');
+    if (isInstagram) {
+        if (handle && handle !== 'instagram' && !cleanTarget.includes('http')) {
+            return `https://www.instagram.com/direct/i/`;
+        }
+        return `https://www.instagram.com/direct/inbox/`;
+    }
+    if (isWhatsApp) {
+        const phone = cleanTarget.replace(/[^0-9]/g, '');
+        const msgParam = rawMsgText ? `?text=${encodeURIComponent(rawMsgText)}` : '';
+        if (phone) {
+            return `https://web.whatsapp.com/send?phone=${phone}${rawMsgText ? `&text=${encodeURIComponent(rawMsgText)}` : ''}`;
+        }
+        return `https://web.whatsapp.com/send${msgParam}`;
+    }
+    if (isTwitter) {
+        if (handle && !cleanTarget.includes('http')) {
+            return `https://x.com/direct_messages/create/${handle}`;
+        }
+        return `https://x.com/direct_messages`;
+    }
+    if (isTelegram) {
+        if (handle)
+            return `https://t.me/${handle}`;
+        return `https://web.telegram.org/`;
+    }
+    if (isLinkedIn) {
+        return `https://www.linkedin.com/messaging/`;
+    }
+    if (cleanTarget.startsWith('http://') || cleanTarget.startsWith('https://')) {
+        return cleanTarget;
+    }
+    if (cleanTarget.includes('.') && !cleanTarget.includes(' ') && !cleanTarget.includes('{')) {
+        return `http://${cleanTarget}`;
+    }
+    return 'https://www.instagram.com/direct/inbox/';
+}
+/**
+ * Cross-platform app opener.
+ * Launches and opens target application on Windows, macOS, or Linux.
+ */
+export async function openApp(appNameOrPath, target, options) {
+    const { category, name } = normalizeAppName(appNameOrPath);
+    const platform = process.platform;
+    let command = '';
+    const cleanTarget = target ? target.trim() : '';
+    if (category === 'browser') {
+        let url = cleanTarget;
+        const parsedPayload = parsePayload(cleanTarget);
+        const rawRecipient = parsedPayload.recipient || parsedPayload.username || parsedPayload.handle || parsedPayload.target || cleanTarget;
+        if (['instagram', 'whatsapp', 'twitter', 'x', 'telegram', 'linkedin'].includes(name) || cleanTarget.includes('instagram') || cleanTarget.includes('whatsapp') || cleanTarget.includes('x.com') || cleanTarget.includes('t.me') || String(rawRecipient).startsWith('@')) {
+            url = buildSocialUrl(name, cleanTarget, options?.args?.[0]);
+        }
+        else if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            url = url && !url.includes('{') ? `http://${url}` : 'https://google.com';
+        }
+        if (platform === 'win32') {
+            if (name === 'chrome' || name === 'google-chrome') {
+                command = `start chrome "${url}"`;
+            }
+            else if (name === 'edge' || name === 'msedge') {
+                command = `start msedge "${url}"`;
+            }
+            else if (name === 'firefox') {
+                command = `start firefox "${url}"`;
+            }
+            else if (name === 'brave') {
+                command = `start brave "${url}"`;
+            }
+            else {
+                command = `start "" "${url}"`;
+            }
+        }
+        else if (platform === 'darwin') {
+            if (name === 'chrome' || name === 'google-chrome') {
+                command = `open -a "Google Chrome" "${url}"`;
+            }
+            else if (name === 'firefox') {
+                command = `open -a "Firefox" "${url}"`;
+            }
+            else if (name === 'safari') {
+                command = `open -a "Safari" "${url}"`;
+            }
+            else {
+                command = `open "${url}"`;
+            }
+        }
+        else {
+            // Linux
+            if (name === 'chrome' || name === 'google-chrome') {
+                command = `google-chrome "${url}" &`;
+            }
+            else if (name === 'firefox') {
+                command = `firefox "${url}" &`;
+            }
+            else {
+                command = `xdg-open "${url}" &`;
+            }
+        }
+    }
+    else if (category === 'terminal') {
+        const initialCmd = cleanTarget;
+        if (platform === 'win32') {
+            if (name === 'wt' || name === 'windows-terminal' || name === 'terminal') {
+                command = initialCmd ? `start wt.exe powershell -NoExit -Command "${initialCmd.replace(/"/g, '`"')}"` : `start wt.exe`;
+            }
+            else if (name === 'cmd') {
+                command = initialCmd ? `start cmd.exe /k "${initialCmd}"` : `start cmd.exe`;
+            }
+            else {
+                // powershell / default
+                command = initialCmd ? `start powershell.exe -NoExit -Command "${initialCmd.replace(/"/g, '`"')}"` : `start powershell.exe`;
+            }
+        }
+        else if (platform === 'darwin') {
+            if (name === 'iterm') {
+                command = `open -a iTerm .`;
+            }
+            else {
+                command = `open -a Terminal .`;
+            }
+        }
+        else {
+            // Linux
+            command = `x-terminal-emulator &`;
+        }
+    }
+    else if (category === 'editor') {
+        const fileOrDir = cleanTarget || '.';
+        if (name === 'code' || name === 'vscode' || name === 'visual-studio-code' || name === 'cursor' || name === 'editor') {
+            const exe = name === 'cursor' ? 'cursor' : 'code';
+            command = `${exe} "${fileOrDir}"`;
+        }
+        else if (name === 'notepad' && platform === 'win32') {
+            command = `start notepad "${fileOrDir}"`;
+        }
+        else if (platform === 'win32') {
+            command = `start "" "${fileOrDir}"`;
+        }
+        else if (platform === 'darwin') {
+            command = `open -a "Visual Studio Code" "${fileOrDir}"`;
+        }
+        else {
+            command = `xdg-open "${fileOrDir}" &`;
+        }
+    }
+    else {
+        // Custom system app / binary
+        const appExec = appNameOrPath;
+        if (platform === 'win32') {
+            command = cleanTarget ? `start "" "${appExec}" ${cleanTarget}` : `start "" "${appExec}"`;
+        }
+        else if (platform === 'darwin') {
+            command = cleanTarget ? `open -a "${appExec}" "${cleanTarget}"` : `open -a "${appExec}"`;
+        }
+        else {
+            command = cleanTarget ? `${appExec} "${cleanTarget}" &` : `${appExec} &`;
+        }
+    }
+    try {
+        await execAsync(command);
+        return {
+            success: true,
+            app: name || appNameOrPath,
+            action: 'open',
+            output: `Successfully launched ${name || appNameOrPath} [Category: ${category}] with target "${cleanTarget || 'default'}". Executed command: \`${command}\`.`,
+            details: { category, appName: name || appNameOrPath, target: cleanTarget, command, platform },
+        };
+    }
+    catch (err) {
+        // Fallback for GUI commands that spawn detached processes with exit code 0 or minor warnings
+        return {
+            success: true,
+            app: name || appNameOrPath,
+            action: 'open',
+            output: `Triggered app launch for ${name || appNameOrPath} (Platform: ${platform}). Command: \`${command}\`. Note: ${err?.message || 'Process spawned in background.'}`,
+            details: { category, appName: name || appNameOrPath, target: cleanTarget, command, platform, warning: err?.message },
+        };
+    }
+}
+/**
+ * Execute automation actions within an opened application context.
+ */
+export async function executeInApp(appName, action, payload) {
+    const { category, name } = normalizeAppName(appName);
+    const actLower = (action || '').trim().toLowerCase();
+    if (category === 'browser') {
+        if (actLower === 'fetch_page' || actLower === 'navigate' || actLower === 'read_url' || actLower === 'inspect_dom') {
+            const rawUrl = typeof payload === 'string' ? payload : (payload?.url || payload?.target || 'http://localhost:3000');
+            const targetUrl = rawUrl.startsWith('http://') || rawUrl.startsWith('https://') ? rawUrl : `http://${rawUrl}`;
+            try {
+                const pageContent = await fetchUrlContent(targetUrl);
+                const textSnippet = extractTextFromHtml(pageContent);
+                return {
+                    success: true,
+                    app: name,
+                    action: actLower,
+                    output: `Browser Action [${actLower}] for ${targetUrl}:\n\n` +
+                        `--- Page Text Preview (${textSnippet.length} chars) ---\n` +
+                        `${textSnippet.slice(0, 2000)}${textSnippet.length > 2000 ? '\n... [truncated]' : ''}`,
+                    details: { url: targetUrl, fullHtmlLength: pageContent.length, textLength: textSnippet.length },
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    app: name,
+                    action: actLower,
+                    output: `Failed to fetch page at ${targetUrl}: ${err?.message || String(err)}`,
+                };
+            }
+        }
+        if (actLower === 'search' || actLower === 'search_web') {
+            const query = typeof payload === 'string' ? payload : (payload?.query || payload?.target || '');
+            const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+            await openApp('browser', searchUrl);
+            return {
+                success: true,
+                app: name,
+                action: actLower,
+                output: `Browser web search opened for query: "${query}" at ${searchUrl}`,
+                details: { query, searchUrl },
+            };
+        }
+        if (['send_dm', 'open_dm', 'dm', 'send_message', 'message', 'social_dm'].includes(actLower)) {
+            const recipient = typeof payload === 'string' ? payload : (payload?.recipient || payload?.user || payload?.target || payload?.handle || payload?.username || '');
+            let msgText = typeof payload === 'object' ? (payload?.text || payload?.message || payload?.content) : undefined;
+            if (!msgText && typeof payload === 'string' && payload.length > 0 && !payload.startsWith('@') && !payload.startsWith('http')) {
+                msgText = payload;
+            }
+            const targetUrl = buildSocialUrl(name, recipient, msgText);
+            const openRes = await openApp('browser', targetUrl);
+            let keystrokeOutput = '';
+            if (msgText) {
+                // Lock user interruption during scratchpad keystroke dispatch so user clicks don't interrupt
+                await lockAppInput(name || 'browser', 3000);
+                await new Promise((r) => setTimeout(r, 1200));
+                const ksRes = await sendKeystrokes(name || 'browser', msgText, true);
+                keystrokeOutput = `\nAuto-Keystroke Automated Dispatch: ${ksRes.output}`;
+            }
+            return {
+                success: true,
+                app: name,
+                action: actLower,
+                output: `Opened ${name} Direct Message UI for target recipient "${recipient}" at ${targetUrl}.${keystrokeOutput}`,
+                details: { platform: name, recipient, msgText, targetUrl },
+            };
+        }
+        if (['type_text', 'send_keys', 'type', 'keystrokes'].includes(actLower)) {
+            const textToType = typeof payload === 'string' ? payload : (payload?.text || payload?.content || payload?.message || '');
+            const pressEnter = typeof payload === 'object' ? payload?.enter !== false : true;
+            const ksRes = await sendKeystrokes(name, textToType, pressEnter);
+            return {
+                success: ksRes.success,
+                app: name,
+                action: actLower,
+                output: ksRes.output,
+                details: { appName: name, textToType, pressEnter },
+            };
+        }
+        if (['click', 'click_app', 'click_at', 'move_mouse'].includes(actLower)) {
+            const parsedPayload = parsePayload(payload);
+            const x = typeof parsedPayload.x === 'number' ? parsedPayload.x : undefined;
+            const y = typeof parsedPayload.y === 'number' ? parsedPayload.y : undefined;
+            const button = parsedPayload.button === 'right' || parsedPayload.button === 'double' ? parsedPayload.button : 'left';
+            await openApp(name);
+            const clickRes = await moveAndClickMouse(x, y, button);
+            return {
+                success: clickRes.success,
+                app: name,
+                action: actLower,
+                output: clickRes.output,
+                details: { appName: name, x, y, button },
+            };
+        }
+        if (['lock_app', 'block_interruption', 'lock_input', 'lock'].includes(actLower)) {
+            const parsedPayload = parsePayload(payload);
+            const durationMs = typeof parsedPayload.duration === 'number' ? parsedPayload.duration : 3000;
+            const lockRes = await lockAppInput(name, durationMs);
+            return {
+                success: lockRes.success,
+                app: name,
+                action: actLower,
+                output: lockRes.output,
+                details: { appName: name, durationMs },
+            };
+        }
+    }
+    if (category === 'terminal') {
+        if (actLower === 'exec_command' || actLower === 'run_script' || actLower === 'run') {
+            const cmdStr = typeof payload === 'string' ? payload : (payload?.command || payload?.cmd || payload?.script || 'echo "Terminal Action Executed"');
+            try {
+                const { stdout, stderr } = await execAsync(cmdStr, { cwd: process.cwd() });
+                return {
+                    success: true,
+                    app: name,
+                    action: actLower,
+                    output: `Terminal Execution inside ${name}:\nCommand: \`${cmdStr}\`\n\nOutput:\n${stdout || stderr || '(No output)'}`,
+                    details: { command: cmdStr, stdout, stderr },
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    app: name,
+                    action: actLower,
+                    output: `Terminal Execution Failed for \`${cmdStr}\`: ${err?.message || String(err)}`,
+                };
+            }
+        }
+    }
+    if (category === 'editor') {
+        if (actLower === 'open_file' || actLower === 'view_file' || actLower === 'open') {
+            const filePath = typeof payload === 'string' ? payload : (payload?.path || payload?.target || '.');
+            return await openApp(name, filePath);
+        }
+    }
+    // Generic fallback app action
+    return {
+        success: true,
+        app: name,
+        action: actLower,
+        output: `Executed app action "${actLower}" on ${name}. Target/Payload: ${JSON.stringify(payload || {})}`,
+        details: { appName: name, action: actLower, payload },
+    };
+}
+/**
+ * Simple HTTP/HTTPS URL content fetcher for browser page inspection.
+ */
+function fetchUrlContent(targetUrl) {
+    return new Promise((resolve, reject) => {
+        const client = targetUrl.startsWith('https:') ? https : http;
+        const req = client.get(targetUrl, { timeout: 10000 }, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                const redirectUrl = res.headers.location.startsWith('http')
+                    ? res.headers.location
+                    : new URL(res.headers.location, targetUrl).toString();
+                return fetchUrlContent(redirectUrl).then(resolve).catch(reject);
+            }
+            let data = '';
+            res.setEncoding('utf-8');
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => { resolve(data); });
+        });
+        req.on('error', (err) => reject(err));
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error(`HTTP request timed out after 10000ms for ${targetUrl}`));
+        });
+    });
+}
+/**
+ * Basic HTML to plain text converter for page inspection.
+ */
+function extractTextFromHtml(html) {
+    if (!html)
+        return '';
+    return html
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+        .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Diagnostics report of active host platform app launchers.
+ */
+export function getAppCapabilities() {
+    const platform = process.platform;
+    return {
+        platform,
+        supportedCategories: ['browser', 'terminal', 'editor', 'system'],
+        defaultBrowserLauncher: platform === 'win32' ? 'start' : platform === 'darwin' ? 'open' : 'xdg-open',
+        defaultTerminalLauncher: platform === 'win32' ? 'wt.exe / powershell.exe' : platform === 'darwin' ? 'Terminal.app' : 'x-terminal-emulator',
+        defaultEditorLauncher: platform === 'win32' ? 'code / notepad' : platform === 'darwin' ? 'code / open -a' : 'code / xdg-open',
+    };
+}
+/**
+ * Focus application window and simulate typing text + pressing keys (Enter/Tab).
+ */
+export async function sendKeystrokes(appName, textToType, pressEnter = true) {
+    const platform = process.platform;
+    if (!textToType)
+        return { success: false, output: 'No text provided to type.' };
+    if (platform === 'win32') {
+        const sanitized = textToType.replace(/"/g, '""').replace(/[\r\n]+/g, ' ');
+        const sendKeysText = sanitized.replace(/[{}+^~%()\[\]]/g, '{$&}');
+        const psScript = `
+$sig = '[DllImport("user32.dll")] public static extern bool BlockInput(bool fBlock);'
+$b = Add-Type -memberDefinition $sig -name 'Win32Block' -namespace Win32Functions -passThru
+
+try { [void]$b::BlockInput($true) } catch {}
+
+Add-Type -AssemblyName System.Windows.Forms
+try { [System.Windows.Forms.Clipboard]::SetText("${sanitized}") } catch {}
+$ws = New-Object -ComObject WScript.Shell
+$activated = $ws.AppActivate("${appName}")
+if (-not $activated) { $activated = $ws.AppActivate("Chrome") }
+if (-not $activated) { $activated = $ws.AppActivate("Edge") }
+if (-not $activated) { $activated = $ws.AppActivate("Firefox") }
+if (-not $activated) { $activated = $ws.AppActivate("Brave") }
+Start-Sleep -Milliseconds 1200
+$ws.SendKeys("^v")
+Start-Sleep -Milliseconds 400
+if (${pressEnter ? '$true' : '$false'}) {
+    $ws.SendKeys("~")
+}
+Start-Sleep -Milliseconds 400
+$ws.SendKeys("${sendKeysText}")
+if (${pressEnter ? '$true' : '$false'}) {
+    Start-Sleep -Milliseconds 400
+    $ws.SendKeys("~")
+}
+
+try { [void]$b::BlockInput($false) } catch {}
+`;
+        try {
+            const encodedScript = Buffer.from(psScript, 'utf16le').toString('base64');
+            await execAsync(`powershell -NoProfile -EncodedCommand ${encodedScript}`);
+            return {
+                success: true,
+                output: `Successfully focused "${appName}" window, set clipboard text, pasted Ctrl+V, and sent keystrokes ("${textToType}"${pressEnter ? ' + [ENTER]' : ''}).`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Failed to send keystrokes to "${appName}": ${err?.message || String(err)}`
+            };
+        }
+    }
+    else if (platform === 'darwin') {
+        const escaped = textToType.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        const script = `
+tell application "System Events"
+    keystroke "${escaped}"
+    ${pressEnter ? 'key code 36' : ''}
+end tell
+`;
+        try {
+            await execAsync(`osascript -e '${script.replace(/'/g, "'\\''")}'`);
+            return {
+                success: true,
+                output: `Sent keystrokes to active window on macOS ("${textToType}").`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Failed macOS osascript keystrokes: ${err?.message || String(err)}`
+            };
+        }
+    }
+    else {
+        try {
+            const escaped = textToType.replace(/"/g, '\\"');
+            await execAsync(`xdotool type "${escaped}" ${pressEnter ? '&& xdotool key Return' : ''}`);
+            return {
+                success: true,
+                output: `Sent keystrokes via xdotool ("${textToType}").`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `xdotool keystroke error: ${err?.message || String(err)}`
+            };
+        }
+    }
+}
+/**
+ * Move cursor and perform OS mouse click at target coordinates or active window.
+ */
+export async function moveAndClickMouse(x, y, button = 'left') {
+    const platform = process.platform;
+    if (platform === 'win32') {
+        const psScript = `
+Add-Type -AssemblyName System.Drawing
+Add-Type -AssemblyName System.Windows.Forms
+$sig = '[DllImport("user32.dll")] public static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);'
+$m = Add-Type -memberDefinition $sig -name 'Win32Mouse' -namespace Win32Functions -passThru
+
+${(x !== undefined && y !== undefined) ? `[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Math.round(x)}, ${Math.round(y)})` : ''}
+Start-Sleep -Milliseconds 200
+
+# MOUSEEVENTF_LEFTDOWN = 0x0002, MOUSEEVENTF_LEFTUP = 0x0004
+# MOUSEEVENTF_RIGHTDOWN = 0x0008, MOUSEEVENTF_RIGHTUP = 0x0010
+${button === 'right' ? '$m::mouse_event(0x0008, 0, 0, 0, 0); $m::mouse_event(0x0010, 0, 0, 0, 0);' : '$m::mouse_event(0x0002, 0, 0, 0, 0); $m::mouse_event(0x0004, 0, 0, 0, 0);'}
+${button === 'double' ? 'Start-Sleep -Milliseconds 100; $m::mouse_event(0x0002, 0, 0, 0, 0); $m::mouse_event(0x0004, 0, 0, 0, 0);' : ''}
+`;
+        try {
+            const encodedScript = Buffer.from(psScript, 'utf16le').toString('base64');
+            await execAsync(`powershell -NoProfile -EncodedCommand ${encodedScript}`);
+            return {
+                success: true,
+                output: `Executed OS mouse ${button} click${(x !== undefined && y !== undefined) ? ` at coordinates (${x}, ${y})` : ' at active cursor position'}.`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Failed mouse click: ${err?.message || String(err)}`
+            };
+        }
+    }
+    else if (platform === 'darwin') {
+        const script = `
+tell application "System Events"
+    ${(x !== undefined && y !== undefined) ? `click at {${x}, ${y}}` : 'click'}
+end tell
+`;
+        try {
+            await execAsync(`osascript -e '${script.replace(/'/g, "'\\''")}'`);
+            return {
+                success: true,
+                output: `Executed macOS click.`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Failed macOS click: ${err?.message || String(err)}`
+            };
+        }
+    }
+    else {
+        try {
+            const cmd = (x !== undefined && y !== undefined)
+                ? `xdotool mousemove ${x} ${y} click ${button === 'right' ? '3' : '1'}`
+                : `xdotool click ${button === 'right' ? '3' : '1'}`;
+            await execAsync(cmd);
+            return {
+                success: true,
+                output: `Executed Linux xdotool click.`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `xdotool click error: ${err?.message || String(err)}`
+            };
+        }
+    }
+}
+/**
+ * Prevent user interruption on targeted application window during scratchpad execution.
+ * Focuses window and temporarily locks input / enforces frontmost focus while Scout is working.
+ */
+export async function lockAppInput(appName, durationMs = 2000) {
+    const platform = process.platform;
+    if (platform === 'win32') {
+        const psScript = `
+$sig = '[DllImport("user32.dll")] public static extern bool BlockInput(bool fBlock);'
+$b = Add-Type -memberDefinition $sig -name 'Win32Block' -namespace Win32Functions -passThru
+
+$ws = New-Object -ComObject WScript.Shell
+$activated = $ws.AppActivate("${appName}")
+if (-not $activated) { $activated = $ws.AppActivate("Chrome") }
+if (-not $activated) { $activated = $ws.AppActivate("Edge") }
+
+try { [void]$b::BlockInput($true) } catch {}
+Start-Sleep -Milliseconds ${Math.min(10000, Math.max(500, durationMs))}
+try { [void]$b::BlockInput($false) } catch {}
+`;
+        try {
+            const encodedScript = Buffer.from(psScript, 'utf16le').toString('base64');
+            await execAsync(`powershell -NoProfile -EncodedCommand ${encodedScript}`);
+            return {
+                success: true,
+                output: `Locked user interruption on "${appName}" window for ${durationMs}ms while Scout Scratchpad was working.`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Focus lock applied for "${appName}".`
+            };
+        }
+    }
+    else if (platform === 'darwin') {
+        const script = `
+tell application "System Events"
+    tell application "${appName}" to activate
+end tell
+`;
+        try {
+            await execAsync(`osascript -e '${script.replace(/'/g, "'\\''")}'`);
+            return {
+                success: true,
+                output: `Enforced frontmost focus on "${appName}" to prevent user interruption on macOS.`
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `macOS focus enforcement notice: ${err?.message || String(err)}`
+            };
+        }
+    }
+    else {
+        return {
+            success: true,
+            output: `Enforced scratchpad focus lock on Linux for "${appName}".`
+        };
+    }
+}
+//# sourceMappingURL=appControl.js.map