@sipher.dev/connector-win32-x64 0.6.18 → 0.6.20

package/bin/agents-connector.exe

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/bin/agents-connector.exe
-size: 93402624 bytes
-sha256: 8c2171e4b4e25a9adf00d2f33f3d349d9e3f2aff193c5b54da800854adb0da10
+size: 93425152 bytes
+sha256: 02f6236c070b296004bbdfb42ac7d1be7fbc5709242a9633942fb788b7413d8c

package/bin/machine-indicator.ps1

@@ -0,0 +1,381 @@
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+Add-Type -ReferencedAssemblies System.Windows.Forms, System.Drawing -TypeDefinition @'
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Windows.Forms;
+
+internal static class IndicatorNative
+{
+    [StructLayout(LayoutKind.Sequential)]
+    private struct UserObjectFlags
+    {
+        public int Inherit;
+        public int Reserved;
+        public uint Flags;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct OsVersion
+    {
+        public uint Size;
+        public uint Major;
+        public uint Minor;
+        public uint Build;
+        public uint Platform;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+        public string ServicePack;
+    }
+
+    [DllImport("user32.dll")]
+    private static extern IntPtr GetProcessWindowStation();
+    [DllImport("user32.dll", EntryPoint = "GetUserObjectInformationW")]
+    private static extern bool GetStationFlags(IntPtr station, int index, out UserObjectFlags flags, uint size, out uint needed);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    private static extern bool GetUserObjectInformation(IntPtr handle, int index, StringBuilder value, uint size, out uint needed);
+    [DllImport("user32.dll")]
+    private static extern IntPtr OpenInputDesktop(uint flags, bool inherit, uint access);
+    [DllImport("user32.dll")]
+    private static extern bool CloseDesktop(IntPtr desktop);
+    [DllImport("user32.dll")]
+    private static extern IntPtr GetThreadDesktop(uint threadId);
+    [DllImport("kernel32.dll")]
+    private static extern uint GetCurrentThreadId();
+    [DllImport("ntdll.dll", CharSet = CharSet.Unicode)]
+    private static extern int RtlGetVersion(ref OsVersion version);
+    [DllImport("user32.dll")]
+    private static extern bool SetWindowDisplayAffinity(IntPtr window, uint affinity);
+    [DllImport("user32.dll")]
+    private static extern bool SetWindowPos(IntPtr window, IntPtr after, int left, int top, int width, int height, uint flags);
+    [DllImport("user32.dll")]
+    private static extern bool GetWindowDisplayAffinity(IntPtr window, out uint affinity);
+    [DllImport("user32.dll")]
+    internal static extern bool SetLayeredWindowAttributes(IntPtr window, uint color, byte alpha, uint flags);
+    [DllImport("user32.dll")]
+    private static extern bool SetProcessDPIAware();
+    [DllImport("shcore.dll")]
+    private static extern int SetProcessDpiAwareness(int awareness);
+    [DllImport("user32.dll")]
+    private static extern IntPtr MonitorFromPoint(Point point, uint flags);
+    [DllImport("shcore.dll")]
+    private static extern int GetDpiForMonitor(IntPtr monitor, int type, out uint horizontal, out uint vertical);
+
+    internal static bool InteractiveStation()
+    {
+        UserObjectFlags flags;
+        uint needed;
+        return Process.GetCurrentProcess().SessionId != 0 &&
+            GetStationFlags(GetProcessWindowStation(), 1, out flags, (uint)Marshal.SizeOf(typeof(UserObjectFlags)), out needed) &&
+            (flags.Flags & 1) != 0;
+    }
+
+    internal static bool InputDesktop()
+    {
+        IntPtr input = OpenInputDesktop(0, false, 1);
+        if (input == IntPtr.Zero) return false;
+        try
+        {
+            uint needed;
+            StringBuilder inputName = new StringBuilder(256);
+            StringBuilder ownName = new StringBuilder(256);
+            return GetUserObjectInformation(input, 2, inputName, 512, out needed) &&
+                GetUserObjectInformation(GetThreadDesktop(GetCurrentThreadId()), 2, ownName, 512, out needed) &&
+                inputName.ToString() == "Default" && ownName.ToString() == inputName.ToString();
+        }
+        finally { CloseDesktop(input); }
+    }
+
+    internal static bool CaptureExclusionAvailable()
+    {
+        OsVersion version = new OsVersion();
+        version.Size = (uint)Marshal.SizeOf(typeof(OsVersion));
+        return RtlGetVersion(ref version) == 0 && version.Build >= 19041;
+    }
+
+    internal static bool Exclude(IntPtr window)
+    {
+        uint affinity;
+        return CaptureExclusionAvailable() && SetWindowDisplayAffinity(window, 0x11) &&
+            GetWindowDisplayAffinity(window, out affinity) && affinity == 0x11;
+    }
+
+    internal static void SetBounds(IntPtr window, Rectangle bounds)
+    {
+        if (!SetWindowPos(window, IntPtr.Zero, bounds.Left, bounds.Top, bounds.Width, bounds.Height, 0x14))
+            throw new InvalidOperationException("Cannot size machine indicator.");
+    }
+
+    internal static void EnableDpi()
+    {
+        try { SetProcessDpiAwareness(2); }
+        catch (DllNotFoundException) { SetProcessDPIAware(); }
+        catch (EntryPointNotFoundException) { SetProcessDPIAware(); }
+    }
+
+    internal static float Scale(Screen screen)
+    {
+        try
+        {
+            uint horizontal, vertical;
+            if (GetDpiForMonitor(MonitorFromPoint(screen.Bounds.Location, 2), 0, out horizontal, out vertical) == 0)
+                return Math.Max(1, horizontal / 96f);
+        }
+        catch (DllNotFoundException) { }
+        catch (EntryPointNotFoundException) { }
+        return 1;
+    }
+}
+
+internal sealed class IndicatorWindow : Form
+{
+    internal bool CaptureExcluded;
+    private Rectangle bounds;
+    private readonly bool label;
+    private readonly float scale;
+    private string state;
+
+    internal IndicatorWindow(Rectangle bounds, bool label, float scale, string state)
+    {
+        this.label = label;
+        this.scale = scale;
+        this.state = state;
+        this.bounds = bounds;
+        AutoScaleMode = AutoScaleMode.None;
+        FormBorderStyle = FormBorderStyle.None;
+        ShowInTaskbar = false;
+        StartPosition = FormStartPosition.Manual;
+        Bounds = bounds;
+        TopMost = true;
+        DoubleBuffered = true;
+    }
+
+    protected override bool ShowWithoutActivation { get { return true; } }
+
+    protected override CreateParams CreateParams
+    {
+        get
+        {
+            CreateParams parameters = base.CreateParams;
+            parameters.ExStyle |= 0x080800A8;
+            return parameters;
+        }
+    }
+
+    protected override void OnHandleCreated(EventArgs args)
+    {
+        base.OnHandleCreated(args);
+        if (!IndicatorNative.SetLayeredWindowAttributes(Handle, 0, 255, 2))
+            throw new InvalidOperationException("Cannot make machine indicator click-through.");
+        CaptureExcluded = IndicatorNative.Exclude(Handle);
+        if (!CaptureExcluded)
+            bounds.Size = new Size(Math.Min(bounds.Width, 240), Math.Min(bounds.Height, 26));
+        IndicatorNative.SetBounds(Handle, bounds);
+    }
+
+    protected override void OnShown(EventArgs args)
+    {
+        base.OnShown(args);
+        IndicatorNative.SetBounds(Handle, bounds);
+    }
+
+    protected override void WndProc(ref Message message)
+    {
+        if (message.Msg == 0x84) { message.Result = new IntPtr(-1); return; }
+        if (message.Msg == 0x21) { message.Result = new IntPtr(3); return; }
+        base.WndProc(ref message);
+    }
+
+    internal void SetState(string next)
+    {
+        state = next;
+        Invalidate();
+    }
+
+    protected override void OnPaint(PaintEventArgs args)
+    {
+        Color accent = state == "held" ? Color.FromArgb(218, 53, 53) : Color.FromArgb(211, 142, 18);
+        args.Graphics.Clear(accent);
+        if (!label) return;
+        using (Font font = new Font("Segoe UI", Math.Min(16, 12 * scale), FontStyle.Bold, GraphicsUnit.Pixel))
+        {
+            TextRenderer.DrawText(args.Graphics, state == "held" ? "Agent working" : "Agents may start work",
+                font, ClientRectangle, Color.White,
+                TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.SingleLine);
+        }
+    }
+}
+
+public sealed class VesperMachineIndicator : ApplicationContext
+{
+    private readonly object gate = new object();
+    private string state = "hidden";
+    private long received = Stopwatch.GetTimestamp();
+    private bool inputClosed;
+    private string displayed = "hidden";
+    private string layout = "";
+    private bool fallback;
+    private bool fallbackLogged;
+    private readonly List<IndicatorWindow> windows = new List<IndicatorWindow>();
+    private readonly System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
+
+    private VesperMachineIndicator()
+    {
+        Thread reader = new Thread(ReadInput);
+        reader.IsBackground = true;
+        reader.Start();
+        timer.Interval = 250;
+        timer.Tick += Tick;
+        timer.Start();
+    }
+
+    private void ReadInput()
+    {
+        try
+        {
+            char[] line = new char[11];
+            int length = 0;
+            for (;;)
+            {
+                int value = Console.In.Read();
+                if (value < 0) break;
+                if (value == '\n')
+                {
+                    int count = length > 0 && line[length - 1] == '\r' ? length - 1 : length;
+                    string next = new string(line, 0, count);
+                    if (next != "held" && next != "windowOpen" && next != "hidden")
+                        throw new InvalidOperationException("Invalid machine indicator state.");
+                    lock (gate) { state = next; received = Stopwatch.GetTimestamp(); }
+                    length = 0;
+                }
+                else
+                {
+                    if (length == line.Length) throw new InvalidOperationException("Machine indicator state too long.");
+                    line[length++] = (char)value;
+                }
+            }
+        }
+        catch (Exception error) { Console.Error.WriteLine(error.Message); }
+        finally { lock (gate) { inputClosed = true; } }
+    }
+
+    private void Tick(object sender, EventArgs args)
+    {
+        string next;
+        bool closed;
+        lock (gate)
+        {
+            closed = inputClosed;
+            next = (Stopwatch.GetTimestamp() - received) / (double)Stopwatch.Frequency >= 150 ? "hidden" : state;
+        }
+        if (closed) { ExitThread(); return; }
+        if (!IndicatorNative.InputDesktop()) next = "hidden";
+        if (next == "hidden")
+        {
+            ClearWindows();
+            displayed = "hidden";
+            return;
+        }
+        Screen[] screens = Screen.AllScreens;
+        StringBuilder signature = new StringBuilder();
+        foreach (Screen screen in screens)
+            signature.Append(screen.DeviceName).Append(screen.Bounds).Append(screen.WorkingArea).Append(IndicatorNative.Scale(screen));
+        bool failed = !fallback && windows.Exists(delegate(IndicatorWindow window) { return !window.CaptureExcluded; });
+        if (windows.Count == 0 || signature.ToString() != layout || failed)
+        {
+            ClearWindows();
+            layout = signature.ToString();
+            fallback = !IndicatorNative.CaptureExclusionAvailable() || failed;
+            if (!fallback)
+            {
+                foreach (Screen screen in screens)
+                {
+                    if (CreateEdges(screen, next)) continue;
+                    fallback = true;
+                    ClearWindows();
+                    break;
+                }
+            }
+            if (fallback)
+            {
+                if (!fallbackLogged)
+                {
+                    Console.Error.WriteLine("Machine indicator capture exclusion unavailable; using tiny 240x26 markers (visible in captures).");
+                    fallbackLogged = true;
+                }
+                foreach (Screen screen in screens)
+                {
+                    Rectangle bounds = screen.Bounds;
+                    IndicatorWindow tiny = new IndicatorWindow(new Rectangle(bounds.Left, bounds.Top,
+                        Math.Min(bounds.Width, 240), Math.Min(bounds.Height, 26)), true, 1, next);
+                    windows.Add(tiny);
+                    tiny.Show();
+                }
+            }
+        }
+        if (next != displayed)
+            foreach (IndicatorWindow window in windows) window.SetState(next);
+        displayed = next;
+    }
+
+    private bool CreateEdges(Screen screen, string next)
+    {
+        float scale = IndicatorNative.Scale(screen);
+        Rectangle bounds = screen.Bounds;
+        int edge = Math.Max(2, (int)(3 * scale));
+        Rectangle[] edges = {
+            new Rectangle(bounds.Left, bounds.Top, bounds.Width, edge),
+            new Rectangle(bounds.Left, bounds.Bottom - edge, bounds.Width, edge),
+            new Rectangle(bounds.Left, bounds.Top + edge, edge, Math.Max(1, bounds.Height - edge * 2)),
+            new Rectangle(bounds.Right - edge, bounds.Top + edge, edge, Math.Max(1, bounds.Height - edge * 2)),
+            new Rectangle(bounds.Left + edge, bounds.Top + edge, Math.Min(320, (int)(240 * scale)), Math.Min(36, (int)(26 * scale)))
+        };
+        int index = 0;
+        foreach (Rectangle rectangle in edges)
+        {
+            IndicatorWindow window = new IndicatorWindow(rectangle, index++ == 4, scale, next);
+            windows.Add(window);
+            IntPtr handle = window.Handle;
+            if (!window.CaptureExcluded) return false;
+        }
+        foreach (IndicatorWindow window in windows)
+            if (!window.Visible) window.Show();
+        return true;
+    }
+
+    private void ClearWindows()
+    {
+        foreach (IndicatorWindow window in windows) window.Dispose();
+        windows.Clear();
+    }
+
+    protected override void ExitThreadCore()
+    {
+        timer.Stop();
+        ClearWindows();
+        base.ExitThreadCore();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing) { timer.Dispose(); ClearWindows(); }
+        base.Dispose(disposing);
+    }
+
+    public static void Run()
+    {
+        if (!IndicatorNative.InteractiveStation())
+            throw new InvalidOperationException("Machine indicator requires an interactive window station outside session 0.");
+        IndicatorNative.EnableDpi();
+        Application.SetUnhandledExceptionMode(UnhandledExceptionMode.ThrowException);
+        using (VesperMachineIndicator indicator = new VesperMachineIndicator())
+            Application.Run(indicator);
+    }
+}
+'@
+[VesperMachineIndicator]::Run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sipher.dev/connector-win32-x64",
-  "version": "0.6.18",
+  "version": "0.6.20",
   "description": "Internal self-contained Vesper Machine connector for win32/x64.",
   "type": "module",
   "private": false,

package/release-manifest.json

@@ -1 +1 @@
-{"schemaVersion":1,"releaseId":"1aa68774-9ead-4df1-8321-b6199c044565","runtimeVersion":"0.6.18","bunVersion":"1.4.0","packageName":"@sipher.dev/connector-win32-x64","platform":"win32","arch":"x64","protocol":{"min":3,"max":3},"rescue":{"min":1,"max":1},"launcherSchemaVersion":2,"executable":"bin/agents-connector.exe","files":[{"path":"bin/agents-connector.exe","type":"file","size":93402624,"mode":493,"sha256":"8c2171e4b4e25a9adf00d2f33f3d349d9e3f2aff193c5b54da800854adb0da10"},{"path":"package.json","type":"file","size":415,"mode":420,"sha256":"ad4d2eaef85cc83741b4b205f2b2d22e320f4b1689882ebaa0cc0f40a7bb99b1"},{"path":"release-trust-anchor.json","type":"file","size":420,"mode":420,"sha256":"d088185aa1dc8fef0cefa1bdb9b8a6588318ce6b26918c8f73cc467166111da9"}]}
+{"schemaVersion":1,"releaseId":"633a2ce5-27ef-4bab-bda2-76ada3511af5","runtimeVersion":"0.6.20","bunVersion":"1.4.0","packageName":"@sipher.dev/connector-win32-x64","platform":"win32","arch":"x64","protocol":{"min":3,"max":3},"rescue":{"min":1,"max":1},"launcherSchemaVersion":2,"executable":"bin/agents-connector.exe","files":[{"path":"bin/agents-connector.exe","type":"file","size":93425152,"mode":493,"sha256":"02f6236c070b296004bbdfb42ac7d1be7fbc5709242a9633942fb788b7413d8c"},{"path":"bin/machine-indicator.ps1","type":"file","size":14795,"mode":420,"sha256":"cb15c59a59a62e2f0b87a85d0d2aeb7415d9d05c33795d0cc46a8170a2b13797"},{"path":"package.json","type":"file","size":415,"mode":420,"sha256":"a029f9df185cd560fed5dfe771e8752a9ab0c186894b744d90634b1ac71e911e"},{"path":"release-trust-anchor.json","type":"file","size":420,"mode":420,"sha256":"931a02789cfb4bbf38d4a8237245578af7e49f13b429fa4dfdd23950bc1ed852"}]}

package/release-manifest.sig

@@ -1 +1 @@
-z+ol+IkKTLerxoKc72tcF+iC74p9cPKJZ6JvHGopOhebpaZ8fKGs++fQi4LjLEHQmLGvtlaiRe5qVYYG0RzvAg==
+mIZZGF/7qlJK1lm74KbqFzpk+Qxh/Ptw1EmPq49DMMpYB2ENP3pUe05DKIGBnW4osBN5BaNP1ZvFPwBZIBpiAg==

package/release-trust-anchor.json

@@ -4,8 +4,8 @@
   "npmRegistryOrigin": "https://registry.npmjs.org",
   "publicKey": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAOjoSJrN1tu1cMZp/biuSMAdqsIGshWkyttGYtlmcDSs=\n-----END PUBLIC KEY-----\n",
   "latest": {
-    "sequence": 38,
-    "indexVersion": "0.6.17",
-    "digest": "617f5617025c9066dedb9e03f744cefec06fc05c12f93432df09084845168639"
+    "sequence": 40,
+    "indexVersion": "0.6.19",
+    "digest": "9b50c01ab82f895620f3b181655b4b935d14e188e0e75666275a07e2c337b6e7"
   }
 }