copilot-liku-cli 0.0.1

package/src/main/ui-automation/keyboard/input.js

@@ -0,0 +1,179 @@
+/**
+ * Keyboard Input Module
+ * 
+ * Type text and send key combinations.
+ * @module ui-automation/keyboard
+ */
+
+const { executePowerShellScript } = require('../core/powershell');
+const { log, sleep } = require('../core/helpers');
+
+/**
+ * Type text character by character
+ * 
+ * @param {string} text - Text to type
+ * @param {Object} [options] - Type options
+ * @param {number} [options.delay=50] - Delay between characters in ms
+ * @returns {Promise<{success: boolean}>}
+ */
+async function typeText(text, options = {}) {
+  const { delay = 50 } = options;
+  
+  // Escape special chars for PowerShell
+  const escapedText = text
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "''")
+    .replace(/`/g, '``');
+  
+  const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+$text = '${escapedText}'
+foreach ($char in $text.ToCharArray()) {
+    [System.Windows.Forms.SendKeys]::SendWait($char)
+    Start-Sleep -Milliseconds ${delay}
+}
+Write-Output "typed"
+`;
+
+  const result = await executePowerShellScript(psScript);
+  const success = result.stdout.includes('typed');
+  log(`TypeText "${text.substring(0, 20)}${text.length > 20 ? '...' : ''}" - ${success ? 'success' : 'failed'}`);
+  
+  return { success };
+}
+
+/**
+ * Send keyboard shortcut or key combination
+ * 
+ * Uses SendKeys format:
+ * - ^ = Ctrl
+ * - % = Alt
+ * - + = Shift
+ * - {ENTER}, {TAB}, {ESC}, {DELETE}, {BACKSPACE}
+ * - {F1}-{F12}
+ * - {UP}, {DOWN}, {LEFT}, {RIGHT}
+ * - {HOME}, {END}, {PGUP}, {PGDN}
+ * 
+ * @param {string} keys - Key combination in SendKeys format
+ * @returns {Promise<{success: boolean}>}
+ */
+async function sendKeys(keys) {
+  const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait('${keys.replace(/'/g, "''")}')
+Write-Output "sent"
+`;
+
+  const result = await executePowerShellScript(psScript);
+  const success = result.stdout.includes('sent');
+  log(`SendKeys "${keys}" - ${success ? 'success' : 'failed'}`);
+  
+  return { success };
+}
+
+/**
+ * Press a key down (for holding modifiers)
+ * 
+ * @param {number} vkCode - Virtual key code
+ * @returns {Promise<{success: boolean}>}
+ */
+async function keyDown(vkCode) {
+  const psScript = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+
+public class KeyboardHelper {
+    [StructLayout(LayoutKind.Sequential)]
+    public struct INPUT { public uint type; public KEYBDINPUT ki; ulong padding; }
+    
+    [StructLayout(LayoutKind.Sequential)]
+    public struct KEYBDINPUT {
+        public ushort wVk, wScan; public uint dwFlags, time; public IntPtr dwExtraInfo;
+    }
+    
+    [DllImport("user32.dll")] 
+    public static extern uint SendInput(uint n, INPUT[] inputs, int size);
+    
+    public static void KeyDown(ushort vk) {
+        var inp = new INPUT { type = 1, ki = new KEYBDINPUT { wVk = vk } };
+        SendInput(1, new[] { inp }, Marshal.SizeOf(typeof(INPUT)));
+    }
+}
+'@
+[KeyboardHelper]::KeyDown(${vkCode})
+Write-Output "down"
+`;
+
+  const result = await executePowerShellScript(psScript);
+  return { success: result.stdout.includes('down') };
+}
+
+/**
+ * Release a key
+ * 
+ * @param {number} vkCode - Virtual key code
+ * @returns {Promise<{success: boolean}>}
+ */
+async function keyUp(vkCode) {
+  const psScript = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+
+public class KeyboardHelper {
+    [StructLayout(LayoutKind.Sequential)]
+    public struct INPUT { public uint type; public KEYBDINPUT ki; ulong padding; }
+    
+    [StructLayout(LayoutKind.Sequential)]
+    public struct KEYBDINPUT {
+        public ushort wVk, wScan; public uint dwFlags, time; public IntPtr dwExtraInfo;
+    }
+    
+    [DllImport("user32.dll")] 
+    public static extern uint SendInput(uint n, INPUT[] inputs, int size);
+    
+    public static void KeyUp(ushort vk) {
+        var inp = new INPUT { type = 1, ki = new KEYBDINPUT { wVk = vk, dwFlags = 0x0002 } };
+        SendInput(1, new[] { inp }, Marshal.SizeOf(typeof(INPUT)));
+    }
+}
+'@
+[KeyboardHelper]::KeyUp(${vkCode})
+Write-Output "up"
+`;
+
+  const result = await executePowerShellScript(psScript);
+  return { success: result.stdout.includes('up') };
+}
+
+/**
+ * Common virtual key codes
+ */
+const VK = {
+  SHIFT: 0x10,
+  CTRL: 0x11,
+  ALT: 0x12,
+  ENTER: 0x0D,
+  TAB: 0x09,
+  ESC: 0x1B,
+  SPACE: 0x20,
+  BACKSPACE: 0x08,
+  DELETE: 0x2E,
+  LEFT: 0x25,
+  UP: 0x26,
+  RIGHT: 0x27,
+  DOWN: 0x28,
+  HOME: 0x24,
+  END: 0x23,
+  PAGEUP: 0x21,
+  PAGEDOWN: 0x22,
+};
+
+module.exports = {
+  typeText,
+  sendKeys,
+  keyDown,
+  keyUp,
+  VK,
+};

package/src/main/ui-automation/mouse/click.js

@@ -0,0 +1,186 @@
+/**
+ * Mouse Click Operations
+ * 
+ * Click and double-click with window focus handling.
+ * @module ui-automation/mouse/click
+ */
+
+const { CONFIG } = require('../config');
+const { executePowerShellScript } = require('../core/powershell');
+const { sleep, log } = require('../core/helpers');
+
+/**
+ * Click at coordinates using SendInput (most reliable)
+ * 
+ * @param {number} x - X coordinate
+ * @param {number} y - Y coordinate
+ * @param {'left'|'right'|'middle'} [button='left'] - Mouse button
+ * @param {Object} [options] - Click options
+ * @param {boolean} [options.focusWindow=true] - Focus window before clicking
+ * @returns {Promise<{success: boolean, coordinates: {x: number, y: number}}>}
+ */
+async function clickAt(x, y, button = 'left', options = {}) {
+  x = Math.round(x);
+  y = Math.round(y);
+  const { focusWindow = true } = options;
+  
+  const buttonFlags = {
+    left: { down: '0x0002', up: '0x0004' },
+    right: { down: '0x0008', up: '0x0010' },
+    middle: { down: '0x0020', up: '0x0040' },
+  };
+  
+  const flags = buttonFlags[button] || buttonFlags.left;
+  
+  const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public class MouseHelper {
+    [StructLayout(LayoutKind.Sequential)]
+    public struct INPUT {
+        public uint type;
+        public MOUSEINPUT mi;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct MOUSEINPUT {
+        public int dx;
+        public int dy;
+        public uint mouseData;
+        public uint dwFlags;
+        public uint time;
+        public IntPtr dwExtraInfo;
+    }
+
+    [DllImport("user32.dll", SetLastError = true)]
+    public static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);
+
+    [DllImport("user32.dll")]
+    public static extern IntPtr WindowFromPoint(int x, int y);
+
+    [DllImport("user32.dll")]
+    public static extern IntPtr GetAncestor(IntPtr hwnd, uint gaFlags);
+
+    [DllImport("user32.dll")]
+    public static extern bool SetForegroundWindow(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);
+
+    [DllImport("user32.dll")]
+    public static extern uint GetWindowThreadProcessId(IntPtr hWnd, IntPtr lpdwProcessId);
+
+    [DllImport("kernel32.dll")]
+    public static extern uint GetCurrentThreadId();
+
+    [DllImport("user32.dll")]
+    public static extern IntPtr GetForegroundWindow();
+
+    [DllImport("user32.dll")]
+    public static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto)]
+    public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
+
+    public const int GWL_EXSTYLE = -20;
+    public const int WS_EX_LAYERED = 0x80000;
+    public const uint GA_ROOT = 2;
+
+    public static IntPtr GetRealWindow(int x, int y) {
+        IntPtr hwnd = WindowFromPoint(x, y);
+        if (hwnd == IntPtr.Zero) return IntPtr.Zero;
+
+        // Skip transparent overlays
+        for (int i = 0; i < 10; i++) {
+            int exStyle = GetWindowLong(hwnd, GWL_EXSTYLE);
+            bool isLayered = (exStyle & WS_EX_LAYERED) != 0;
+            
+            StringBuilder sb = new StringBuilder(256);
+            GetWindowText(hwnd, sb, 256);
+            string title = sb.ToString();
+            
+            // Skip layered windows with no title (likely overlays)
+            if (!isLayered || !string.IsNullOrEmpty(title)) {
+                return GetAncestor(hwnd, GA_ROOT);
+            }
+            
+            IntPtr parent = GetAncestor(hwnd, 1);
+            if (parent == IntPtr.Zero || parent == hwnd) break;
+            hwnd = parent;
+        }
+        
+        return GetAncestor(hwnd, GA_ROOT);
+    }
+
+    public static void ForceForeground(IntPtr hwnd) {
+        IntPtr fg = GetForegroundWindow();
+        uint fgThread = GetWindowThreadProcessId(fg, IntPtr.Zero);
+        uint curThread = GetCurrentThreadId();
+        
+        if (fgThread != curThread) {
+            AttachThreadInput(curThread, fgThread, true);
+            SetForegroundWindow(hwnd);
+            AttachThreadInput(curThread, fgThread, false);
+        } else {
+            SetForegroundWindow(hwnd);
+        }
+    }
+
+    public static void Click(uint downFlag, uint upFlag) {
+        var down = new INPUT { type = 0, mi = new MOUSEINPUT { dwFlags = downFlag } };
+        var up = new INPUT { type = 0, mi = new MOUSEINPUT { dwFlags = upFlag } };
+        SendInput(1, new[] { down }, Marshal.SizeOf(typeof(INPUT)));
+        System.Threading.Thread.Sleep(30);
+        SendInput(1, new[] { up }, Marshal.SizeOf(typeof(INPUT)));
+    }
+}
+'@
+
+# Move cursor
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${x}, ${y})
+Start-Sleep -Milliseconds ${CONFIG.CLICK_DELAY}
+
+${focusWindow ? `
+# Focus the window under cursor
+$hwnd = [MouseHelper]::GetRealWindow(${x}, ${y})
+if ($hwnd -ne [IntPtr]::Zero) {
+    [MouseHelper]::ForceForeground($hwnd)
+    Start-Sleep -Milliseconds ${CONFIG.FOCUS_DELAY}
+}
+` : ''}
+
+# Click
+[MouseHelper]::Click(${flags.down}, ${flags.up})
+Write-Output "clicked"
+`;
+
+  const result = await executePowerShellScript(psScript);
+  
+  const success = result.stdout.includes('clicked');
+  log(`${button} click at (${x}, ${y}) - ${success ? 'success' : 'failed'}`);
+  
+  return { success, coordinates: { x, y } };
+}
+
+/**
+ * Double-click at coordinates
+ * 
+ * @param {number} x - X coordinate
+ * @param {number} y - Y coordinate
+ * @param {'left'|'right'} [button='left'] - Mouse button
+ * @returns {Promise<{success: boolean, coordinates: {x: number, y: number}}>}
+ */
+async function doubleClickAt(x, y, button = 'left') {
+  await clickAt(x, y, button);
+  await sleep(50);
+  return await clickAt(x, y, button);
+}
+
+module.exports = {
+  clickAt,
+  doubleClickAt,
+};

package/src/main/ui-automation/mouse/drag.js

@@ -0,0 +1,88 @@
+/**
+ * Mouse Drag Operations
+ * 
+ * Drag from one point to another.
+ * @module ui-automation/mouse/drag
+ */
+
+const { executePowerShellScript } = require('../core/powershell');
+const { log } = require('../core/helpers');
+
+/**
+ * Drag from one point to another
+ * 
+ * @param {number} fromX - Start X coordinate
+ * @param {number} fromY - Start Y coordinate  
+ * @param {number} toX - End X coordinate
+ * @param {number} toY - End Y coordinate
+ * @param {Object} [options] - Drag options
+ * @param {number} [options.steps=10] - Number of intermediate steps
+ * @param {number} [options.stepDelay=10] - Delay between steps in ms
+ * @returns {Promise<{success: boolean}>}
+ */
+async function drag(fromX, fromY, toX, toY, options = {}) {
+  const { steps = 10, stepDelay = 10 } = options;
+  
+  const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+
+public class DragHelper {
+    [StructLayout(LayoutKind.Sequential)]
+    public struct INPUT { public uint type; public MOUSEINPUT mi; }
+    
+    [StructLayout(LayoutKind.Sequential)]
+    public struct MOUSEINPUT {
+        public int dx, dy; public uint mouseData, dwFlags, time; public IntPtr dwExtraInfo;
+    }
+    
+    [DllImport("user32.dll")] 
+    public static extern uint SendInput(uint n, INPUT[] inputs, int size);
+    
+    public static void MouseDown() {
+        var inp = new INPUT { type = 0, mi = new MOUSEINPUT { dwFlags = 0x0002 } };
+        SendInput(1, new[] { inp }, Marshal.SizeOf(typeof(INPUT)));
+    }
+    
+    public static void MouseUp() {
+        var inp = new INPUT { type = 0, mi = new MOUSEINPUT { dwFlags = 0x0004 } };
+        SendInput(1, new[] { inp }, Marshal.SizeOf(typeof(INPUT)));
+    }
+}
+'@
+
+# Move to start
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Math.round(fromX)}, ${Math.round(fromY)})
+Start-Sleep -Milliseconds 50
+
+# Press down
+[DragHelper]::MouseDown()
+Start-Sleep -Milliseconds 50
+
+# Move in steps
+$steps = ${steps}
+for ($i = 1; $i -le $steps; $i++) {
+    $progress = $i / $steps
+    $x = [int](${Math.round(fromX)} + (${Math.round(toX)} - ${Math.round(fromX)}) * $progress)
+    $y = [int](${Math.round(fromY)} + (${Math.round(toY)} - ${Math.round(fromY)}) * $progress)
+    [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point($x, $y)
+    Start-Sleep -Milliseconds ${stepDelay}
+}
+
+# Release
+[DragHelper]::MouseUp()
+Write-Output "dragged"
+`;
+
+  const result = await executePowerShellScript(psScript);
+  const success = result.stdout.includes('dragged');
+  log(`Drag from (${fromX}, ${fromY}) to (${toX}, ${toY}) - ${success ? 'success' : 'failed'}`);
+  
+  return { success };
+}
+
+module.exports = {
+  drag,
+};

package/src/main/ui-automation/mouse/index.js

@@ -0,0 +1,30 @@
+/**
+ * Mouse Operations Module
+ * 
+ * @module ui-automation/mouse
+ */
+
+const { moveMouse, getMousePosition } = require('./movement');
+const { clickAt, doubleClickAt } = require('./click');
+const { drag } = require('./drag');
+const { scroll, scrollUp, scrollDown, scrollLeft, scrollRight } = require('./scroll');
+
+module.exports = {
+  // Movement
+  moveMouse,
+  getMousePosition,
+  
+  // Clicks
+  clickAt,
+  doubleClickAt,
+  
+  // Drag
+  drag,
+  
+  // Scrolling
+  scroll,
+  scrollUp,
+  scrollDown,
+  scrollLeft,
+  scrollRight,
+};

package/src/main/ui-automation/mouse/movement.js

@@ -0,0 +1,51 @@
+/**
+ * Mouse Movement
+ * 
+ * Basic mouse position and movement functions.
+ * @module ui-automation/mouse/movement
+ */
+
+const { executePowerShellScript } = require('../core/powershell');
+const { log } = require('../core/helpers');
+
+/**
+ * Move mouse to coordinates
+ * 
+ * @param {number} x - X coordinate
+ * @param {number} y - Y coordinate
+ * @returns {Promise<void>}
+ */
+async function moveMouse(x, y) {
+  x = Math.round(x);
+  y = Math.round(y);
+  
+  const script = `
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${x}, ${y})
+`;
+  await executePowerShellScript(script);
+  log(`Mouse moved to (${x}, ${y})`);
+}
+
+/**
+ * Get current mouse position
+ * 
+ * @returns {Promise<{x: number, y: number}>}
+ */
+async function getMousePosition() {
+  const result = await executePowerShellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+$pos = [System.Windows.Forms.Cursor]::Position
+Write-Output "$($pos.X),$($pos.Y)"
+`);
+  const output = (result.stdout || '').trim();
+  const parts = output.split(',');
+  const x = parseInt(parts[0], 10) || 0;
+  const y = parseInt(parts[1], 10) || 0;
+  return { x, y };
+}
+
+module.exports = {
+  moveMouse,
+  getMousePosition,
+};

package/src/main/ui-automation/mouse/scroll.js

@@ -0,0 +1,116 @@
+/**
+ * Mouse Scroll Operations
+ * 
+ * Vertical and horizontal scrolling.
+ * @module ui-automation/mouse/scroll
+ */
+
+const { executePowerShellScript } = require('../core/powershell');
+const { log } = require('../core/helpers');
+
+/**
+ * Scroll the mouse wheel
+ * 
+ * @param {number} [amount=3] - Lines to scroll (positive = down, negative = up)
+ * @param {Object} [options] - Scroll options
+ * @param {number} [options.x] - X coordinate (current position if omitted)
+ * @param {number} [options.y] - Y coordinate (current position if omitted)
+ * @param {boolean} [options.horizontal=false] - Horizontal scroll instead of vertical
+ * @returns {Promise<{success: boolean}>}
+ */
+async function scroll(amount = 3, options = {}) {
+  const { x, y, horizontal = false } = options;
+  
+  // WHEEL_DELTA = 120 per "click"
+  const wheelDelta = Math.round(amount * 120);
+  
+  const psScript = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+
+public class ScrollHelper {
+    [StructLayout(LayoutKind.Sequential)]
+    public struct INPUT { public uint type; public MOUSEINPUT mi; }
+    
+    [StructLayout(LayoutKind.Sequential)]
+    public struct MOUSEINPUT {
+        public int dx, dy; public uint mouseData, dwFlags, time; public IntPtr dwExtraInfo;
+    }
+    
+    [DllImport("user32.dll")] 
+    public static extern uint SendInput(uint n, INPUT[] inputs, int size);
+    
+    [DllImport("user32.dll")]
+    public static extern bool GetCursorPos(out System.Drawing.Point pt);
+    
+    public static void Scroll(int delta, bool horizontal) {
+        // MOUSEEVENTF_WHEEL = 0x0800, MOUSEEVENTF_HWHEEL = 0x01000
+        uint flags = horizontal ? 0x01000u : 0x0800u;
+        var inp = new INPUT { 
+            type = 0, 
+            mi = new MOUSEINPUT { mouseData = (uint)delta, dwFlags = flags } 
+        };
+        SendInput(1, new[] { inp }, Marshal.SizeOf(typeof(INPUT)));
+    }
+}
+'@
+
+Add-Type -AssemblyName System.Windows.Forms
+
+${x !== undefined && y !== undefined ? `[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Math.round(x)}, ${Math.round(y)}); Start-Sleep -Milliseconds 50` : '# Use current position'}
+
+[ScrollHelper]::Scroll(${-wheelDelta}, $${horizontal})
+Write-Output "scrolled"
+`;
+
+  const result = await executePowerShellScript(psScript);
+  const success = result.stdout.includes('scrolled');
+  log(`Scroll ${horizontal ? 'horizontal' : 'vertical'} amount=${amount} - ${success ? 'success' : 'failed'}`);
+  
+  return { success };
+}
+
+/**
+ * Scroll up
+ * @param {number} [lines=3] - Lines to scroll
+ * @returns {Promise<{success: boolean}>}
+ */
+async function scrollUp(lines = 3) {
+  return scroll(-Math.abs(lines));
+}
+
+/**
+ * Scroll down
+ * @param {number} [lines=3] - Lines to scroll
+ * @returns {Promise<{success: boolean}>}
+ */
+async function scrollDown(lines = 3) {
+  return scroll(Math.abs(lines));
+}
+
+/**
+ * Scroll left
+ * @param {number} [amount=3] - Amount to scroll
+ * @returns {Promise<{success: boolean}>}
+ */
+async function scrollLeft(amount = 3) {
+  return scroll(-Math.abs(amount), { horizontal: true });
+}
+
+/**
+ * Scroll right
+ * @param {number} [amount=3] - Amount to scroll
+ * @returns {Promise<{success: boolean}>}
+ */
+async function scrollRight(amount = 3) {
+  return scroll(Math.abs(amount), { horizontal: true });
+}
+
+module.exports = {
+  scroll,
+  scrollUp,
+  scrollDown,
+  scrollLeft,
+  scrollRight,
+};