deepseek-computer-use 0.0.0-stage → 0.1.1

package/native/Program.cs

@@ -0,0 +1,160 @@
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Threading;
+
+// ---------------------------------------------------------------------------
+// stdio JSON-lines bridge: one request object per line in, one response object
+// per line out. The DSH plugin owns the process lifetime; this helper owns the
+// UI Automation / SendInput / capture state so element indexes stay valid.
+// ---------------------------------------------------------------------------
+public static class Program
+{
+    static IPlatformDriver _driver;
+    /// Set by the close RPC: the loop stops after flushing the response.
+    public static bool CloseRequested;
+    /// 130 mirrors Codex's "the user pressed Esc" exit code.
+    public static int RequestedExitCode;
+
+    public static int Main(string[] args)
+    {
+        try
+        {
+            Console.OutputEncoding = new UTF8Encoding(false);
+            Console.InputEncoding = new UTF8Encoding(false);
+        }
+        catch { }
+
+        _driver = CreateDriver();
+
+        if (args.Length > 0 && args[0] == "--self-test")
+        {
+            return SelfTest();
+        }
+
+        string line;
+        while (true)
+        {
+            try { line = Console.ReadLine(); }
+            catch (Exception) { break; }
+            if (line == null) break;
+            if (line.Trim().Length == 0) continue;
+            string response = Handle(line);
+            Console.Out.Write(response);
+            Console.Out.Write('\n');
+            Console.Out.Flush();
+            if (CloseRequested || RequestedExitCode != 0) break;
+        }
+        try { if (_driver != null) _driver.Dispose(); } catch { }
+        return RequestedExitCode;
+    }
+
+    static IPlatformDriver CreateDriver()
+    {
+        string forced = Environment.GetEnvironmentVariable("DSH_CU_PLATFORM");
+        if (!string.IsNullOrEmpty(forced) && forced != "windows")
+            throw new NotSupportedException("platform '" + forced + "' has no driver implementation yet; only windows is available");
+        return new WindowsDriver();
+    }
+
+    static int SelfTest()
+    {
+        Dictionary<string, object> ping = _driver.Ping(new Dictionary<string, object>());
+        Dictionary<string, object> wins = _driver.ListWindows(new Dictionary<string, object>());
+        Dictionary<string, object> report = new Dictionary<string, object>();
+        report["ok"] = true;
+        report["platform"] = _driver.PlatformName;
+        report["windowCount"] = wins["count"];
+        report["driver"] = ping;
+        Console.Out.Write(Json.ToJson(report));
+        Console.Out.Write('\n');
+        Console.Out.Flush();
+        return 0;
+    }
+
+    static string Handle(string line)
+    {
+        long id = 0;
+        try
+        {
+            Dictionary<string, object> req = Json.AsObject(Json.Parse(line));
+            if (req == null) throw new ToolError("bad_request", "request must be a JSON object");
+            id = Json.GetLong(req, "id", 0);
+            string method = Json.GetString(req, "method");
+            Dictionary<string, object> p = Json.AsObject(Json.Get(req, "params"));
+            if (p == null) p = new Dictionary<string, object>();
+            // Codex ships the budget with every call (x-oai-cua-request-budget-ms) and the
+            // helper honours it; here it bounds capture waits and marks overruns.
+            Budget.Begin(Json.GetLong(p, "__budgetMs", 0));
+            try { if (_driver != null) _driver.Maintenance(); } catch { }
+            object result = Dispatch(method, p);
+            return Ok(id, result);
+        }
+        catch (ToolError te)
+        {
+            return Fail(id, te.Code, te.Message);
+        }
+        catch (Exception ex)
+        {
+            return Fail(id, "internal_error", ex.GetType().Name + ": " + ex.Message);
+        }
+    }
+
+    static object Dispatch(string method, Dictionary<string, object> p)
+    {
+        if (string.IsNullOrEmpty(method)) throw new ToolError("bad_request", "request.method is required");
+        switch (method)
+        {
+            case "ping": return _driver.Ping(p);
+            case "hello": return _driver.Hello(p);
+            case "restore_cursor": return _driver.RestoreCursor(p);
+            case "close": return _driver.Close(p);
+            case "list_windows": return _driver.ListWindows(p);
+            case "list_apps": return _driver.ListApps(p);
+            case "get_window": return _driver.GetWindow(p);
+            case "launch_app": return _driver.LaunchApp(p);
+            case "get_window_state": return _driver.GetWindowState(p);
+            case "click": return _driver.Click(p);
+            case "press_key": return _driver.PressKey(p);
+            case "type_text": return _driver.TypeText(p);
+            case "scroll": return _driver.Scroll(p);
+            case "drag": return _driver.Drag(p);
+            case "set_value": return _driver.SetValue(p);
+            case "perform_secondary_action": return _driver.PerformSecondaryAction(p);
+            case "activate_window": return _driver.ActivateWindow(p);
+            case "overlay_show": return _driver.OverlayShow(p);
+            case "overlay_hide": return _driver.OverlayHide(p);
+            case "configure": return _driver.Configure(p);
+            case "approve_app": return _driver.ApproveApp(p);
+            case "end_turn": return _driver.EndTurn(p);
+            case "start_audio_recording": return _driver.StartAudioRecording(p);
+            case "stop_audio_recording": return _driver.StopAudioRecording(p);
+            case "shutdown": return new Dictionary<string, object> { { "bye", true } };
+            default: throw new ToolError("unknown_method", "unknown method '" + method + "'");
+        }
+    }
+
+    static string Ok(long id, object result)
+    {
+        Dictionary<string, object> d = new Dictionary<string, object>();
+        d["id"] = id;
+        d["ok"] = true;
+        d["result"] = result;
+        return Json.ToJson(d);
+    }
+
+    static string Fail(long id, string code, string message)
+    {
+        Dictionary<string, object> err = new Dictionary<string, object>();
+        err["code"] = code;
+        err["message"] = message;
+        Dictionary<string, object> d = new Dictionary<string, object>();
+        d["id"] = id;
+        d["ok"] = false;
+        d["error"] = err;
+        return Json.ToJson(d);
+    }
+}

package/native/audio/Audio.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net48</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <PlatformTarget>x64</PlatformTarget>
+    <AssemblyName>dsh-cu-audio</AssemblyName>
+    <RootNamespace>DshCuAudio</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
+    <PackageReference Include="NAudio" Version="2.2.1" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="System.Windows.Forms" />
+  </ItemGroup>
+</Project>

package/native/audio/Program.cs

@@ -0,0 +1,95 @@
+using System;
+using System.IO;
+using System.Threading;
+using NAudio.Wave;
+using NAudio.Wave.SampleProviders;
+
+namespace DshCuAudio
+{
+    /// WASAPI loopback recorder: captures whatever the machine is playing, which is
+    /// what Codex's start/stop_audio_recording expose (gated behind SKY_ENABLE_AUDIO).
+    /// Stops on max duration, on the helper's stop file, or on Ctrl+C.
+    internal static class Program
+    {
+        private static int Main(string[] args)
+        {
+            string output = Path.Combine(Path.GetTempPath(), "dsh-cu-audio.wav");
+            int maxMs = 60000;
+            string stopFile = null;
+            for (int i = 0; i < args.Length - 1; i++)
+            {
+                if (args[i] == "--out") output = args[i + 1];
+                else if (args[i] == "--max-ms") int.TryParse(args[i + 1], out maxMs);
+                else if (args[i] == "--stop-file") stopFile = args[i + 1];
+            }
+            if (maxMs < 500) maxMs = 500;
+
+            try
+            {
+                // Record at the device mix format first, then normalise to the 24 kHz
+                // stereo 16-bit WAV that Codex returns.
+                string devicePath = output + ".device.wav";
+                try { if (File.Exists(devicePath)) File.Delete(devicePath); } catch { }
+                using (var capture = new WasapiLoopbackCapture())
+                using (var writer = new WaveFileWriter(devicePath, capture.WaveFormat))
+                {
+                    var stopped = new ManualResetEventSlim(false);
+                    Exception failure = null;
+                    capture.DataAvailable += (sender, e) =>
+                    {
+                        try
+                        {
+                            if (e.BytesRecorded > 0) writer.Write(e.Buffer, 0, e.BytesRecorded);
+                        }
+                        catch (Exception ex) { failure = ex; stopped.Set(); }
+                    };
+                    capture.RecordingStopped += (sender, e) => { stopped.Set(); };
+
+                    capture.StartRecording();
+                    Console.WriteLine("recording started: " + capture.WaveFormat.SampleRate + "Hz " +
+                        capture.WaveFormat.Channels + "ch -> " + output);
+
+                    var deadline = DateTime.UtcNow.AddMilliseconds(maxMs);
+                    while (DateTime.UtcNow < deadline && !stopped.IsSet)
+                    {
+                        if (stopFile != null && File.Exists(stopFile)) break;
+                        Thread.Sleep(150);
+                    }
+
+                    capture.StopRecording();
+                    stopped.Wait(3000);
+                    writer.Flush();
+
+                    if (failure != null) { Console.Error.WriteLine(failure.GetType().Name + ": " + failure.Message); return 6; }
+
+                    writer.Dispose();
+                    Normalize(devicePath, output);
+                    try { File.Delete(devicePath); } catch { }
+                    long bytes = new FileInfo(output).Length;
+                    Console.WriteLine("recorded 24kHz stereo, " + bytes + " bytes -> " + output);
+                    return 0;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine(ex.GetType().Name + ": " + ex.Message);
+                return 5;
+            }
+        }
+
+        /// Resample/convert the device-format capture into 24 kHz stereo 16-bit PCM.
+        static void Normalize(string source, string destination)
+        {
+            using (var reader = new WaveFileReader(source))
+            {
+                ISampleProvider samples = reader.ToSampleProvider();
+                if (samples.WaveFormat.Channels == 1)
+                    samples = new MonoToStereoSampleProvider(samples);
+                ISampleProvider resampled = samples.WaveFormat.SampleRate == 24000
+                    ? samples
+                    : new WdlResamplingSampleProvider(samples, 24000);
+                WaveFileWriter.CreateWaveFile16(destination, resampled);
+            }
+        }
+    }
+}

package/native/wgcfw/Capture.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net48</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>disable</Nullable>
+    <PlatformTarget>x64</PlatformTarget>
+    <AssemblyName>dsh-cu-capture</AssemblyName>
+    <RootNamespace>DshCuCapture</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
+    <PackageReference Include="SharpDX.Direct3D11" Version="4.2.0" />
+    <PackageReference Include="SharpDX.DXGI" Version="4.2.0" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Windows.winmd">
+      <HintPath>C:\Program Files (x86)\Windows Kits\10\UnionMetadata\10.0.22621.0\Windows.winmd</HintPath>
+      <IsWinMDFile>true</IsWinMDFile>
+    </Reference>
+    <Reference Include="System.Runtime.WindowsRuntime" />
+  </ItemGroup>
+</Project>

package/native/wgcfw/Program.cs

@@ -0,0 +1,249 @@
+using System;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Runtime.InteropServices;
+using System.Threading;
+using SharpDX.Direct3D;
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using Windows.Graphics.Capture;
+using Windows.Graphics.DirectX;
+using Windows.Graphics.DirectX.Direct3D11;
+using D3D11Device = SharpDX.Direct3D11.Device;
+using D3D11Texture2D = SharpDX.Direct3D11.Texture2D;
+using DXGIDevice = SharpDX.DXGI.Device;
+
+namespace DshCuCapture
+{
+    /// Windows.Graphics.Capture for .NET Framework 4.8 - the same API Codex uses,
+    /// with no .NET 8 runtime dependency (Framework 4.8 ships with Windows 10/11).
+    internal static class Program
+    {
+        [ComImport]
+        [Guid("A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1")]
+        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        private interface IDirect3DDxgiInterfaceAccess
+        {
+            [PreserveSig] int GetInterface(ref Guid iid, out IntPtr result);
+        }
+
+        [DllImport("d3d11.dll", ExactSpelling = true)]
+        private static extern int CreateDirect3D11DeviceFromDXGIDevice(IntPtr dxgiDevice, out IntPtr graphicsDevice);
+
+        [DllImport("combase.dll", CharSet = CharSet.Unicode)]
+        private static extern int WindowsCreateString(string source, int length, out IntPtr hstring);
+
+        [DllImport("combase.dll")]
+        private static extern int RoGetActivationFactory(IntPtr activatableClassId, ref Guid iid, out IntPtr factory);
+
+        [DllImport("combase.dll")]
+        private static extern int WindowsDeleteString(IntPtr hstring);
+
+        [DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory")]
+        private static extern void CopyMemory(IntPtr destination, IntPtr source, int length);
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        private delegate int CreateForWindowDelegate(IntPtr thisPtr, IntPtr hwnd, ref Guid iid, out IntPtr item);
+        private delegate int CreateForMonitorDelegate(IntPtr thisPtr, IntPtr hmon, ref Guid iid, out IntPtr item);
+
+        [DllImport("user32.dll")] private static extern IntPtr MonitorFromPoint(POINT pt, uint flags);
+        [StructLayout(LayoutKind.Sequential)] private struct POINT { public int X, Y; }
+
+        private static bool _suppressBorder = true;
+
+        private sealed class Slot
+        {
+            public Bitmap Bitmap;
+            public Exception Error;
+        }
+
+        private static int Main(string[] args)
+        {
+            long hwnd = 0;
+            bool monitor = false;
+            bool redactAll = false;
+            bool suppressBorder = true;
+            var redactRects = new System.Collections.Generic.List<System.Drawing.Rectangle>();
+            string output = "capture.png";
+            int timeoutMs = 2000;
+            for (int i = 0; i < args.Length - 1; i++)
+            {
+                if (args[i] == "--redact")
+                {
+                    string[] parts = args[i + 1].Split(',');
+                    if (parts.Length == 4)
+                        redactRects.Add(new System.Drawing.Rectangle(int.Parse(parts[0]), int.Parse(parts[1]), int.Parse(parts[2]), int.Parse(parts[3])));
+                }
+                else if (args[i] == "--hwnd") long.TryParse(args[i + 1], out hwnd);
+                else if (args[i] == "--out") output = args[i + 1];
+                else if (args[i] == "--timeout") int.TryParse(args[i + 1], out timeoutMs);
+            }
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i] == "--monitor") monitor = true;
+                else if (args[i] == "--redact-all") redactAll = true;
+                else if (args[i] == "--keep-border") suppressBorder = false;
+            }
+            if (hwnd == 0 && !monitor) { Console.Error.WriteLine("--hwnd or --monitor is required"); return 2; }
+
+            try
+            {
+                GraphicsCaptureItem item = monitor ? CreateMonitorItem() : CreateItem(new IntPtr(hwnd));
+                using (D3D11Device device = new D3D11Device(DriverType.Hardware, DeviceCreationFlags.BgraSupport))
+                using (DXGIDevice dxgi = device.QueryInterface<DXGIDevice>())
+                {
+                    int hr = CreateDirect3D11DeviceFromDXGIDevice(dxgi.NativePointer, out IntPtr winrtDevicePtr);
+                    if (hr < 0) { Console.Error.WriteLine("CreateDirect3D11DeviceFromDXGIDevice hr=0x" + hr.ToString("X8")); return 3; }
+                    IDirect3DDevice winrtDevice;
+                    try { winrtDevice = (IDirect3DDevice)Marshal.GetObjectForIUnknown(winrtDevicePtr); }
+                    finally { Marshal.Release(winrtDevicePtr); }
+
+                    _suppressBorder = suppressBorder;
+                    var slot = new Slot();
+                    using (var pool = Direct3D11CaptureFramePool.CreateFreeThreaded(
+                        winrtDevice, DirectXPixelFormat.B8G8R8A8UIntNormalized, 2, item.Size))
+                    using (var session = pool.CreateCaptureSession(item))
+                    using (var done = new ManualResetEventSlim(false))
+                    {
+                        try { session.IsCursorCaptureEnabled = false; } catch { }
+                        // Windows 11 draws a yellow frame around any captured window. Kill it
+                        // (Codex does the same through its capture-border access path) so the
+                        // border never shows up in the picture or on the user's desktop.
+                        if (_suppressBorder) { try { session.IsBorderRequired = false; } catch { } }
+
+                        Direct3D11CaptureFramePool owner = pool;
+                        D3D11Device gpu = device;
+                        pool.FrameArrived += (sender, e) =>
+                        {
+                            if (slot.Bitmap != null) return;
+                            try
+                            {
+                                using (var frame = owner.TryGetNextFrame())
+                                {
+                                    if (frame == null) return;
+                                    var access = (IDirect3DDxgiInterfaceAccess)frame.Surface;
+                                    Guid iid = new Guid("6f15aaf2-d208-4e89-9ab4-489535d34f9c"); // ID3D11Texture2D
+                                    IntPtr texPtr;
+                                    if (access.GetInterface(ref iid, out texPtr) < 0 || texPtr == IntPtr.Zero) return;
+                                    using (var texture = new D3D11Texture2D(texPtr))
+                                    {
+                                        var desc = texture.Description;
+                                        var stagingDesc = new Texture2DDescription
+                                        {
+                                            Width = desc.Width,
+                                            Height = desc.Height,
+                                            MipLevels = 1,
+                                            ArraySize = 1,
+                                            Format = desc.Format,
+                                            SampleDescription = new SampleDescription(1, 0),
+                                            Usage = ResourceUsage.Staging,
+                                            BindFlags = BindFlags.None,
+                                            CpuAccessFlags = CpuAccessFlags.Read,
+                                            OptionFlags = ResourceOptionFlags.None,
+                                        };
+                                        using (var staging = new D3D11Texture2D(gpu, stagingDesc))
+                                        {
+                                            var context = gpu.ImmediateContext;
+                                            context.CopyResource(texture, staging);
+                                            SharpDX.DataBox box = context.MapSubresource(staging, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None);
+                                            try
+                                            {
+                                                Bitmap bmp = new Bitmap(desc.Width, desc.Height, PixelFormat.Format32bppArgb);
+                                                BitmapData data = bmp.LockBits(new Rectangle(0, 0, desc.Width, desc.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
+                                                for (int y = 0; y < desc.Height; y++)
+                                                {
+                                                    IntPtr src = IntPtr.Add(box.DataPointer, y * box.RowPitch);
+                                                    IntPtr dst = IntPtr.Add(data.Scan0, y * data.Stride);
+                                                    CopyMemory(dst, src, desc.Width * 4);
+                                                }
+                                                bmp.UnlockBits(data);
+                                                slot.Bitmap = bmp;
+                                            }
+                                            finally { context.UnmapSubresource(staging, 0); }
+                                        }
+                                    }
+                                }
+                            }
+                            catch (Exception ex) { slot.Error = ex; }
+                            finally { done.Set(); }
+                        };
+
+                        session.StartCapture();
+                        done.Wait(timeoutMs);
+                        try { session.Dispose(); } catch { }
+                    }
+
+                    if (slot.Error != null) { Console.Error.WriteLine(slot.Error.GetType().Name + ": " + slot.Error.Message); return 6; }
+                    if (slot.Bitmap == null) { Console.Error.WriteLine("no frame arrived (timeout or empty surface)"); return 4; }
+
+                    if (redactAll || redactRects.Count > 0)
+                    {
+                        using (var g = Graphics.FromImage(slot.Bitmap))
+                        {
+                            g.Clear(redactAll ? Color.Black : Color.Transparent);
+                            foreach (var rect in redactRects) g.FillRectangle(Brushes.Black, rect);
+                        }
+                    }
+                    int w = slot.Bitmap.Width, h = slot.Bitmap.Height;
+                    slot.Bitmap.Save(output, ImageFormat.Png);
+                    slot.Bitmap.Dispose();
+                    Console.WriteLine("wgc " + w + "x" + h + " -> " + output);
+                    return 0;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine(ex.GetType().Name + ": " + ex.Message);
+                return 5;
+            }
+        }
+
+        private static GraphicsCaptureItem CreateMonitorItem()
+        {
+            POINT origin = new POINT { X = 0, Y = 0 };
+            IntPtr monitorHandle = MonitorFromPoint(origin, 2); // MONITOR_DEFAULTTONEAREST
+            const string className = "Windows.Graphics.Capture.GraphicsCaptureItem";
+            WindowsCreateString(className, className.Length, out IntPtr hstr);
+            try
+            {
+                Guid interopIid = new Guid("3628E81B-3CAC-4C60-B7F4-23CE0E0C3356");
+                int hr = RoGetActivationFactory(hstr, ref interopIid, out IntPtr factoryPtr);
+                if (hr < 0) throw new COMException("RoGetActivationFactory hr=0x" + hr.ToString("X8"), hr);
+                IntPtr vtable = Marshal.ReadIntPtr(factoryPtr);
+                IntPtr fn = Marshal.ReadIntPtr(vtable, 4 * IntPtr.Size); // CreateForMonitor
+                var createForMonitor = (CreateForMonitorDelegate)Marshal.GetDelegateForFunctionPointer(fn, typeof(CreateForMonitorDelegate));
+                Guid itemIid = new Guid("79C3F95B-31F7-4EC2-A464-632EF5D30760");
+                int hrItem = createForMonitor(factoryPtr, monitorHandle, ref itemIid, out IntPtr itemPtr);
+                Marshal.Release(factoryPtr);
+                if (hrItem < 0) throw new COMException("CreateForMonitor hr=0x" + hrItem.ToString("X8"), hrItem);
+                try { return (GraphicsCaptureItem)Marshal.GetObjectForIUnknown(itemPtr); }
+                finally { Marshal.Release(itemPtr); }
+            }
+            finally { WindowsDeleteString(hstr); }
+        }
+
+        private static GraphicsCaptureItem CreateItem(IntPtr hwnd)
+        {
+            const string className = "Windows.Graphics.Capture.GraphicsCaptureItem";
+            WindowsCreateString(className, className.Length, out IntPtr hstr);
+            try
+            {
+                Guid interopIid = new Guid("3628E81B-3CAC-4C60-B7F4-23CE0E0C3356");
+                int hr = RoGetActivationFactory(hstr, ref interopIid, out IntPtr factoryPtr);
+                if (hr < 0) throw new COMException("RoGetActivationFactory hr=0x" + hr.ToString("X8"), hr);
+
+                IntPtr vtable = Marshal.ReadIntPtr(factoryPtr);
+                IntPtr fn = Marshal.ReadIntPtr(vtable, 3 * IntPtr.Size);
+                var createForWindow = (CreateForWindowDelegate)Marshal.GetDelegateForFunctionPointer(fn, typeof(CreateForWindowDelegate));
+
+                Guid itemIid = new Guid("79C3F95B-31F7-4EC2-A464-632EF5D30760");
+                int hrItem = createForWindow(factoryPtr, hwnd, ref itemIid, out IntPtr itemPtr);
+                Marshal.Release(factoryPtr);
+                if (hrItem < 0) throw new COMException("CreateForWindow hr=0x" + hrItem.ToString("X8"), hrItem);
+                try { return (GraphicsCaptureItem)Marshal.GetObjectForIUnknown(itemPtr); }
+                finally { Marshal.Release(itemPtr); }
+            }
+            finally { WindowsDeleteString(hstr); }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "deepseek-computer-use",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Windows Computer Use for DeepSeek Harness: UIA observation, SendInput actions, Windows.Graphics.Capture — modeled on Codex's window2 API. Community plugin, not an official DeepSeek package.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "native/Json.cs",
+    "native/Driver.cs",
+    "native/Program.cs",
+    "native/Overlay.cs",
+    "native/audio/Audio.csproj",
+    "native/audio/Program.cs",
+    "native/wgcfw/Capture.csproj",
+    "native/wgcfw/Program.cs",
+    "skills",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node lib/build.mjs",
+    "build:helper": "node lib/build.mjs",
+    "test": "node test/integration.mjs",
+    "test:all": "node test/integration.mjs && node test/parity.mjs && node test/parity-js.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "computer-use",
+    "windows",
+    "uia",
+    "desktop-automation",
+    "wgc",
+    "accessibility"
+  ],
+  "license": "MIT",
+  "author": "STARDUSTLC666",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/STARDUSTLC666/deepseek-computer-use.git"
+  },
+  "homepage": "https://github.com/STARDUSTLC666/deepseek-computer-use#readme",
+  "bugs": {
+    "url": "https://github.com/STARDUSTLC666/deepseek-computer-use/issues"
+  },
+  "os": [
+    "win32"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}