@mazees/mark 5.0.0

package/src/main/pc-agent-scripts/pc-overlay.ps1

@@ -0,0 +1,253 @@
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+$cSharpCode = @"
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Text;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using System.Windows.Forms;
+
+public class MarkPcOverlayForm : Form {
+    private const int WH_MOUSE_LL = 14;
+    private const int WH_KEYBOARD_LL = 13;
+    private const uint LLMHF_INJECTED = 0x01;
+    private const uint LLMHF_LOWER_IL_INJECTED = 0x02;
+    private const int WM_KEYDOWN = 0x0100;
+    private const int WM_SYSKEYDOWN = 0x0104;
+
+    private const int VK_S = 0x53;
+    private const int VK_CONTROL = 0x11;
+    private const int VK_SHIFT = 0x10;
+    private const int VK_LCONTROL = 0xA2;
+    private const int VK_RCONTROL = 0xA3;
+    private const int VK_LSHIFT = 0xA0;
+    private const int VK_RSHIFT = 0xA1;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MSLLHOOKSTRUCT {
+        public int x;
+        public int y;
+        public uint mouseData;
+        public uint flags;
+        public uint time;
+        public IntPtr dwExtraInfo;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct KBDLLHOOKSTRUCT {
+        public uint vkCode;
+        public uint scanCode;
+        public uint flags;
+        public uint time;
+        public IntPtr dwExtraInfo;
+    }
+
+    private delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+    private static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, uint dwThreadId);
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool UnhookWindowsHookEx(IntPtr hhk);
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+    private static extern IntPtr GetModuleHandle(string lpModuleName);
+
+    [DllImport("user32.dll")]
+    private static extern short GetAsyncKeyState(int vKey);
+
+    private static IntPtr _mouseHook = IntPtr.Zero;
+    private static IntPtr _kbdHook = IntPtr.Zero;
+    private static HookProc _mouseProc = MouseHookCallback;
+    private static HookProc _kbdProc = KbdHookCallback;
+
+    public static MarkPcOverlayForm Instance = null;
+    public static bool IsAborted = false;
+
+    private Timer pulseTimer;
+    private int pulseAlpha = 255;
+    private bool pulseDec = true;
+
+    public MarkPcOverlayForm() {
+        this.FormBorderStyle = FormBorderStyle.None;
+        this.StartPosition = FormStartPosition.Manual;
+        this.TopMost = true;
+        this.ShowInTaskbar = false;
+        this.Size = new Size(510, 36);
+        this.BackColor = Color.FromArgb(15, 23, 21); // #0f1715 Mark Theme Base
+        this.Opacity = 0.98;
+
+        this.SetStyle(ControlStyles.AllPaintingInWmPaint |
+                      ControlStyles.UserPaint |
+                      ControlStyles.OptimizedDoubleBuffer |
+                      ControlStyles.ResizeRedraw, true);
+
+        Rectangle primary = Screen.PrimaryScreen.Bounds;
+        int x = (primary.Width - this.Width) / 2;
+        int y = 16;
+        this.Location = new Point(x, y);
+
+        pulseTimer = new Timer();
+        pulseTimer.Interval = 40;
+        pulseTimer.Tick += (s, e) => {
+            if (pulseDec) {
+                pulseAlpha -= 14;
+                if (pulseAlpha <= 100) pulseDec = false;
+            } else {
+                pulseAlpha += 14;
+                if (pulseAlpha >= 255) pulseDec = true;
+            }
+            this.Invalidate();
+        };
+        pulseTimer.Start();
+
+        Instance = this;
+        InitHooks();
+    }
+
+    public static void InitHooks() {
+        using (Process curProcess = Process.GetCurrentProcess())
+        using (ProcessModule curModule = curProcess.MainModule) {
+            IntPtr hModule = GetModuleHandle(curModule.ModuleName);
+            _mouseHook = SetWindowsHookEx(WH_MOUSE_LL, _mouseProc, hModule, 0);
+            _kbdHook = SetWindowsHookEx(WH_KEYBOARD_LL, _kbdProc, hModule, 0);
+        }
+
+        AppDomain.CurrentDomain.ProcessExit += (s, e) => {
+            CleanupHooks();
+        };
+    }
+
+    public static void CleanupHooks() {
+        if (_mouseHook != IntPtr.Zero) {
+            UnhookWindowsHookEx(_mouseHook);
+            _mouseHook = IntPtr.Zero;
+        }
+        if (_kbdHook != IntPtr.Zero) {
+            UnhookWindowsHookEx(_kbdHook);
+            _kbdHook = IntPtr.Zero;
+        }
+    }
+
+    public static void TriggerAbort() {
+        if (IsAborted) return;
+        IsAborted = true;
+        Console.WriteLine("{\"event\":\"abort\"}");
+        CleanupHooks();
+        if (Instance != null && !Instance.IsDisposed) {
+            try {
+                Instance.BeginInvoke(new Action(() => {
+                    Instance.Close();
+                }));
+            } catch {}
+        }
+    }
+
+    private static IntPtr MouseHookCallback(int nCode, IntPtr wParam, IntPtr lParam) {
+        if (nCode >= 0) {
+            MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
+
+            // Allow injected events (AI automation) to pass, block physical user movements
+            bool isInjected = (hookStruct.flags & LLMHF_INJECTED) != 0 ||
+                              (hookStruct.flags & LLMHF_LOWER_IL_INJECTED) != 0;
+
+            if (!isInjected) {
+                return (IntPtr)1; // Block physical mouse movement 100%
+            }
+        }
+        return CallNextHookEx(_mouseHook, nCode, wParam, lParam);
+    }
+
+    private static IntPtr KbdHookCallback(int nCode, IntPtr wParam, IntPtr lParam) {
+        if (nCode >= 0 && (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)) {
+            KBDLLHOOKSTRUCT kb = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
+            if (kb.vkCode == VK_S) {
+                bool isCtrl = (GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0 ||
+                              (GetAsyncKeyState(VK_LCONTROL) & 0x8000) != 0 ||
+                              (GetAsyncKeyState(VK_RCONTROL) & 0x8000) != 0;
+                bool isShift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0 ||
+                               (GetAsyncKeyState(VK_LSHIFT) & 0x8000) != 0 ||
+                               (GetAsyncKeyState(VK_RSHIFT) & 0x8000) != 0;
+
+                if (isCtrl && isShift) {
+                    TriggerAbort();
+                    return (IntPtr)1; // Block key
+                }
+            }
+        }
+        return CallNextHookEx(_kbdHook, nCode, wParam, lParam);
+    }
+
+    protected override void OnPaint(PaintEventArgs e) {
+        base.OnPaint(e);
+        Graphics g = e.Graphics;
+        g.SmoothingMode = SmoothingMode.AntiAlias;
+        g.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
+
+        // Background Dark Ground (#0f1715)
+        using (SolidBrush bgBrush = new SolidBrush(Color.FromArgb(15, 23, 21))) {
+            g.FillRectangle(bgBrush, 0, 0, this.Width, this.Height);
+        }
+
+        // Animated Pulsing Red Dot (Recording / Locked state indicator)
+        using (SolidBrush dotBrush = new SolidBrush(Color.FromArgb(pulseAlpha, 239, 68, 68))) {
+            g.FillEllipse(dotBrush, 14, (this.Height - 8) / 2, 8, 8);
+        }
+
+        // Fonts & Typography
+        using (Font fontBold = new Font("Segoe UI", 9.0f, FontStyle.Bold))
+        using (Font fontRegular = new Font("Segoe UI", 9.0f, FontStyle.Regular))
+        using (SolidBrush textGreen = new SolidBrush(Color.FromArgb(31, 184, 84))) // #1fb854 Mark Green
+        using (SolidBrush textWhite = new SolidBrush(Color.FromArgb(240, 240, 240)))
+        using (SolidBrush textMuted = new SolidBrush(Color.FromArgb(150, 165, 158)))
+        using (Pen divPen = new Pen(Color.FromArgb(35, 75, 60), 1.0f))
+        {
+            float curX = 30;
+            float textY = (this.Height - fontRegular.Height) / 2.0f;
+
+            // [MARK PC AUTOMATION]
+            string tag = "MARK PC AUTOMATION";
+            g.DrawString(tag, fontBold, textGreen, curX, textY);
+            curX += g.MeasureString(tag, fontBold).Width + 10;
+
+            // Divider Line 1
+            g.DrawLine(divPen, curX, 8, curX, this.Height - 8);
+            curX += 10;
+
+            // Hotkey Instruction Text
+            string cancelPrefix = "Buka Kunci Mouse: ";
+            g.DrawString(cancelPrefix, fontRegular, textMuted, curX, textY);
+            curX += g.MeasureString(cancelPrefix, fontRegular).Width;
+
+            string hotkey = "Ctrl + Shift + S";
+            g.DrawString(hotkey, fontBold, textGreen, curX, textY);
+        }
+    }
+
+    protected override void Dispose(bool disposing) {
+        if (disposing) {
+            CleanupHooks();
+            if (pulseTimer != null) {
+                pulseTimer.Stop();
+                pulseTimer.Dispose();
+            }
+        }
+        base.Dispose(disposing);
+    }
+}
+"@
+
+Add-Type -TypeDefinition $cSharpCode -ReferencedAssemblies "System.Windows.Forms", "System.Drawing"
+
+[System.Windows.Forms.Application]::EnableVisualStyles()
+
+$overlay = New-Object MarkPcOverlayForm
+[System.Console]::WriteLine("READY")
+[System.Windows.Forms.Application]::Run($overlay)

package/src/main/pc-agent-scripts/pick-folder.ps1

@@ -0,0 +1,33 @@
+[CmdletBinding()]
+param(
+    [string]$Title = "Pilih Folder Workspace Proyek"
+)
+
+$ErrorActionPreference = 'SilentlyContinue'
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+
+Add-Type -AssemblyName System.Windows.Forms
+
+# Gunakan Form TopMost sebagai Owner agar dialog pasti muncul di paling depan
+$owner = New-Object System.Windows.Forms.Form
+$owner.TopMost = $true
+$owner.StartPosition = [System.Windows.Forms.FormStartPosition]::CenterScreen
+$owner.Width = 0
+$owner.Height = 0
+$owner.ShowInTaskbar = $false
+$owner.Opacity = 0
+$owner.Show()
+$owner.Activate()
+
+$dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+$dialog.Description = $Title
+$dialog.ShowNewFolderButton = $true
+
+$res = $dialog.ShowDialog($owner)
+
+if ($res -eq [System.Windows.Forms.DialogResult]::OK -and -not [string]::IsNullOrWhiteSpace($dialog.SelectedPath)) {
+    [Console]::Out.Write($dialog.SelectedPath)
+}
+
+$owner.Close()
+$owner.Dispose()

package/src/main/pc-agent-scripts/read-ui.ps1

@@ -0,0 +1,181 @@
+# read-ui.ps1
+# Windows UIAutomation Accessibility Tree reader for MARK PC Automation
+# Zero Vision Cost: Extracts interactive GUI elements as JSON text (~200-400 tokens)
+
+$ErrorActionPreference = "SilentlyContinue"
+
+Add-Type -AssemblyName UIAutomationClient
+Add-Type -AssemblyName UIAutomationTypes
+Add-Type -AssemblyName System.Windows.Forms
+
+# Get foreground window handle
+$code = @"
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public class Win32 {
+    [DllImport("user32.dll")]
+    public static extern IntPtr GetForegroundWindow();
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
+
+    [DllImport("user32.dll")]
+    public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+
+    [DllImport("user32.dll")]
+    public static extern bool EnumWindows(EnumWindowsProc enumProc, IntPtr lParam);
+
+    [DllImport("user32.dll")]
+    public static extern bool IsWindowVisible(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern bool IsIconic(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern int GetWindowTextLength(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern bool SetForegroundWindow(IntPtr hWnd);
+
+    public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+    public static bool IsMarkWindow(string title) {
+        if (string.IsNullOrWhiteSpace(title)) return true;
+        string t = title.Trim();
+        if (t == "Program Manager" || t == "Default IME" || t.StartsWith("MSCTFIME")) return true;
+        string lower = t.ToLower();
+        if (lower == "mark" || lower.StartsWith("mark -") || lower.StartsWith("mark_pc_stop") || lower.StartsWith("mark_unblock") || lower.Contains("mark agent") || lower.Contains("mark pc automation")) {
+            return true;
+        }
+        return false;
+    }
+
+    public static IntPtr GetTargetWindow() {
+        IntPtr fg = GetForegroundWindow();
+        string fgTitle = "";
+        int fgLen = GetWindowTextLength(fg);
+        if (fgLen > 0) {
+            StringBuilder fgSb = new StringBuilder(fgLen + 1);
+            GetWindowText(fg, fgSb, fgSb.Capacity);
+            fgTitle = fgSb.ToString();
+        }
+
+        if (!IsMarkWindow(fgTitle)) {
+            return fg;
+        }
+
+        IntPtr target = IntPtr.Zero;
+        EnumWindows(delegate(IntPtr hWnd, IntPtr lParam) {
+            if (!IsWindowVisible(hWnd) || IsIconic(hWnd)) return true;
+            int len = GetWindowTextLength(hWnd);
+            if (len <= 0) return true;
+            StringBuilder sb = new StringBuilder(len + 1);
+            GetWindowText(hWnd, sb, sb.Capacity);
+            string title = sb.ToString();
+
+            if (!IsMarkWindow(title)) {
+                target = hWnd;
+                return false;
+            }
+            return true;
+        }, IntPtr.Zero);
+
+        if (target != IntPtr.Zero) {
+            SetForegroundWindow(target);
+            return target;
+        }
+        return fg;
+    }
+}
+"@
+Add-Type -TypeDefinition $code -Language CSharp
+
+$hwnd = [Win32]::GetTargetWindow()
+$titleBuilder = New-Object System.Text.StringBuilder 512
+[Win32]::GetWindowText($hwnd, $titleBuilder, $titleBuilder.Capacity) | Out-Null
+$windowTitle = $titleBuilder.ToString()
+
+$processId = 0
+[Win32]::GetWindowThreadProcessId($hwnd, [ref]$processId) | Out-Null
+$processName = "unknown"
+if ($processId -gt 0) {
+    try {
+        $proc = Get-Process -Id $processId
+        $processName = $proc.ProcessName + ".exe"
+    } catch {}
+}
+
+# Traverse Accessibility Tree of Foreground Window
+$elements = @()
+$idCounter = 1
+
+try {
+    $windowElement = [System.Windows.Automation.AutomationElement]::FromHandle($hwnd)
+    if ($windowElement) {
+        $condition = [System.Windows.Automation.Condition]::TrueCondition
+        $treeWalker = [System.Windows.Automation.TreeWalker]::ControlViewWalker
+        
+        # We search descendants using FindAll with TrueCondition, limited to top 60 interactive elements
+        $allControls = $windowElement.FindAll([System.Windows.Automation.TreeScope]::Descendants, $condition)
+        
+        foreach ($el in $allControls) {
+            if ($idCounter -gt 60) { break }
+            
+            # Check if element is enabled and offscreen=false
+            $enabled = $el.Current.IsEnabled
+            $offscreen = $el.Current.IsOffscreen
+            if (-not $enabled -or $offscreen) { continue }
+
+            $role = $el.Current.ControlType.ProgrammaticName.Replace("ControlType.", "")
+            $interactiveRoles = @("Button", "Edit", "MenuItem", "TabItem", "ComboBox", "CheckBox", "RadioButton", "Hyperlink", "ListItem", "TreeItem", "DataItem", "Text")
+            if ($interactiveRoles -notcontains $role) { continue }
+
+            $name = $el.Current.Name
+            $autoId = $el.Current.AutomationId
+            $rect = $el.Current.BoundingRectangle
+
+            # Skip elements with empty name & empty autoId unless it's an Edit control
+            if ([string]::IsNullOrWhiteSpace($name) -and [string]::IsNullOrWhiteSpace($autoId) -and $role -ne "Edit") {
+                continue
+            }
+
+            # Extract Value if Edit
+            $val = ""
+            if ($role -eq "Edit") {
+                try {
+                    $valuePattern = $el.GetCurrentPattern([System.Windows.Automation.ValuePattern]::Pattern)
+                    if ($valuePattern) { $val = $valuePattern.Current.Value }
+                } catch {}
+            }
+
+            $elementObj = @{
+                id = $idCounter
+                name = if ($name) { $name } else { $autoId }
+                role = $role
+                rect = @([int]$rect.X, [int]$rect.Y, [int]$rect.Width, [int]$rect.Height)
+            }
+            if ($val) {
+                $elementObj["value"] = $val
+            }
+
+            $elements += $elementObj
+            $idCounter++
+        }
+    }
+} catch {
+    # If error reading Accessibility Tree, return empty elements array so caller can fallback to OCR
+}
+
+$output = @{
+    window = $windowTitle
+    process = $processName
+    elements = $elements
+    element_count = $elements.Count
+    method = "uiautomation"
+}
+
+$json = $output | ConvertTo-Json -Depth 5 -Compress
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+Write-Output $json

package/src/main/pc-agent-scripts/take-screenshot.ps1

@@ -0,0 +1,24 @@
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+$screens = [System.Windows.Forms.Screen]::AllScreens
+$results = @()
+
+foreach ($screen in $screens) {
+    $bounds = $screen.Bounds
+    $bitmap = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height
+    $graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+    $graphics.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size)
+
+    $memoryStream = New-Object System.IO.MemoryStream
+    $bitmap.Save($memoryStream, [System.Drawing.Imaging.ImageFormat]::Jpeg)
+    $base64 = [Convert]::ToBase64String($memoryStream.ToArray())
+
+    $graphics.Dispose()
+    $bitmap.Dispose()
+    $memoryStream.Dispose()
+
+    $results += $base64
+}
+
+Write-Output ($results -join '|||')