@react-grab/cli 0.1.37 → 0.1.39

package/dist/read-clipboard.ps1

@@ -0,0 +1,111 @@
+# Windows clipboard reader for `react-grab watch`. Reads CF_UNICODETEXT and the
+# registered "Chromium Web Custom MIME Data Format" (a base::Pickle of web custom
+# data) via Win32, in a single OpenClipboard so the two reads are consistent.
+# Emits { changeCount, text, pickleBase64 } as JSON; the CLI decodes the pickle
+# (shared with macOS/Linux). GetClipboardSequenceNumber gives a cheap monotonic
+# change token for idle polling.
+
+$ErrorActionPreference = "Stop"
+
+$source = @"
+using System;
+using System.Runtime.InteropServices;
+
+public static class RgClip {
+  [DllImport("user32.dll", SetLastError = true)]
+  public static extern bool OpenClipboard(IntPtr hWndNewOwner);
+  [DllImport("user32.dll", SetLastError = true)]
+  public static extern bool CloseClipboard();
+  [DllImport("user32.dll", SetLastError = true)]
+  public static extern IntPtr GetClipboardData(uint uFormat);
+  [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+  public static extern uint RegisterClipboardFormat(string lpszFormat);
+  [DllImport("user32.dll")]
+  public static extern uint GetClipboardSequenceNumber();
+  [DllImport("user32.dll", SetLastError = true)]
+  public static extern bool IsClipboardFormatAvailable(uint format);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  public static extern IntPtr GlobalLock(IntPtr hMem);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  public static extern bool GlobalUnlock(IntPtr hMem);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  public static extern UIntPtr GlobalSize(IntPtr hMem);
+
+  private const uint CF_UNICODETEXT = 13;
+
+  private static byte[] ReadLocked(uint format) {
+    if (!IsClipboardFormatAvailable(format)) return null;
+    IntPtr handle = GetClipboardData(format);
+    if (handle == IntPtr.Zero) return null;
+    IntPtr pointer = GlobalLock(handle);
+    if (pointer == IntPtr.Zero) return null;
+    try {
+      ulong size = GlobalSize(handle).ToUInt64();
+      if (size == 0 || size > int.MaxValue) return null;
+      byte[] bytes = new byte[(int)size];
+      Marshal.Copy(pointer, bytes, 0, (int)size);
+      return bytes;
+    } finally {
+      GlobalUnlock(handle);
+    }
+  }
+
+  public static byte[][] ReadAll(uint customFormat) {
+    byte[][] result = new byte[2][];
+    if (!OpenClipboard(IntPtr.Zero)) return result;
+    try {
+      result[0] = ReadLocked(CF_UNICODETEXT);
+      result[1] = ReadLocked(customFormat);
+    } finally {
+      CloseClipboard();
+    }
+    return result;
+  }
+}
+"@
+
+# Add-Type recompiles on every process start, so the reader is compiled to a
+# cached assembly once and merely loaded on subsequent polls.
+$cacheDir = Join-Path $env:TEMP "react-grab-watch"
+# Key the cached DLL by a hash of the source so a changed reader recompiles
+# instead of loading a stale assembly.
+$sourceHashBytes = [System.Security.Cryptography.SHA256]::Create().ComputeHash([System.Text.Encoding]::UTF8.GetBytes($source))
+$sourceHash = ([System.BitConverter]::ToString($sourceHashBytes) -replace "-", "").Substring(0, 16)
+$cachedDll = Join-Path $cacheDir "RgClipReader-$sourceHash.dll"
+$loaded = $false
+if (Test-Path $cachedDll) {
+  try { Add-Type -Path $cachedDll | Out-Null; $loaded = $true } catch {}
+}
+if (-not $loaded) {
+  try {
+    New-Item -ItemType Directory -Force -Path $cacheDir | Out-Null
+    Add-Type -TypeDefinition $source -Language CSharp -OutputAssembly $cachedDll -ErrorAction Stop | Out-Null
+    Add-Type -Path $cachedDll | Out-Null
+    $loaded = $true
+  } catch {}
+}
+if (-not $loaded) {
+  Add-Type -TypeDefinition $source -Language CSharp | Out-Null
+}
+
+$changeCount = [RgClip]::GetClipboardSequenceNumber()
+$customFormat = [RgClip]::RegisterClipboardFormat("Chromium Web Custom MIME Data Format")
+$blobs = [RgClip]::ReadAll($customFormat)
+
+$text = $null
+if ($null -ne $blobs[0]) {
+  $text = [System.Text.Encoding]::Unicode.GetString($blobs[0]).TrimEnd([char]0)
+}
+
+$pickleBase64 = $null
+if ($null -ne $blobs[1]) {
+  $pickleBase64 = [System.Convert]::ToBase64String($blobs[1])
+}
+
+$payload = [ordered]@{
+  changeCount  = [int64]$changeCount
+  text         = $text
+  pickleBase64 = $pickleBase64
+}
+
+$payload | ConvertTo-Json -Compress

package/dist/read-clipboard.swift

@@ -0,0 +1,35 @@
+import AppKit
+
+// macOS clipboard reader for `react-grab watch`. React Grab's custom MIME type
+// is not exposed directly by Chromium-based browsers: the legacy
+// execCommand("copy") + dataTransfer.setData path lands as a base::Pickle under
+// "org.chromium.web-custom-data"; the async Clipboard API path lands as raw
+// bytes referenced by "org.w3.web-custom-format.map". This reader emits the
+// pickle as base64 (the CLI decodes it, shared with Linux/Windows) and the W3C
+// payload as a resolved string, plus changeCount for cheap idle polling.
+
+let GRAB_MIME = "application/x-react-grab"
+let pasteboard = NSPasteboard.general
+var result: [String: Any] = ["changeCount": pasteboard.changeCount]
+
+if let text = pasteboard.string(forType: .string) {
+  result["text"] = text
+}
+
+if let data = pasteboard.data(forType: NSPasteboard.PasteboardType("org.chromium.web-custom-data")) {
+  result["pickleBase64"] = data.base64EncodedString()
+}
+
+if let mapData = pasteboard.data(
+  forType: NSPasteboard.PasteboardType("org.w3.web-custom-format.map")),
+  let mapString = String(data: mapData, encoding: .utf8),
+  let mapJson = try? JSONSerialization.jsonObject(with: Data(mapString.utf8)) as? [String: String],
+  let pasteboardType = mapJson["web " + GRAB_MIME] ?? mapJson[GRAB_MIME],
+  let raw = pasteboard.data(forType: NSPasteboard.PasteboardType(pasteboardType)),
+  let value = String(data: raw, encoding: .utf8)
+{
+  result["grab"] = value
+}
+
+let outData = (try? JSONSerialization.data(withJSONObject: result, options: [])) ?? Data("{}".utf8)
+FileHandle.standardOutput.write(outData)

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@react-grab/cli",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "bin": {
     "react-grab": "./bin/cli.js"
   },
   "files": [
     "bin",
-    "dist"
+    "dist",
+    "skills"
   ],
   "type": "module",
   "exports": {
@@ -17,6 +18,7 @@
     }
   },
   "dependencies": {
+    "agent-install": "^0.0.5",
     "commander": "^14.0.3",
     "ignore": "^7.0.5",
     "jsonc-parser": "^3.3.1",
@@ -29,11 +31,12 @@
   },
   "devDependencies": {
     "@types/prompts": "^2.4.9",
+    "cross-env": "^10.1.0",
     "vite-plus": "^0.1.20"
   },
   "scripts": {
-    "dev": "vp pack --watch",
-    "build": "rm -rf dist && NODE_ENV=production vp pack",
+    "dev": "node scripts/bundle-skill.mjs --watch",
+    "build": "rm -rf dist skills && node scripts/bundle-skill.mjs && cross-env NODE_ENV=production vp pack && node scripts/copy-native-readers.mjs",
     "test": "vp test run",
     "test:watch": "vp test",
     "lint": "vp lint",

package/skills/react-grab/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: react-grab
+description: >-
+  Use when the user wants a hands-free loop where grabbing UI elements in the
+  browser with React Grab feeds tasks to the agent automatically, with no
+  copy-paste or manual handoff. Triggers: "watch react grab", "monitor my
+  grabs", "auto-process react grab", "watch my clipboard for grabs". Not for a
+  one-off paste of a single grab; this is the continuous, always-on loop.
+disable-model-invocation: true
+---
+
+# React Grab
+
+The user selects UI elements in their browser and copies them with React Grab.
+`npx grab watch` blocks until the next grab lands on the clipboard, prints it as
+one line of JSON, and exits. Run it, act on the grab, run it again: that is the
+whole loop. No background process, no notifications, no polling, just a blocking
+command you keep re-running until the user says stop.
+
+## The loop
+
+1. Run `npx grab watch` in the foreground. It blocks until the user grabs
+   something, then prints the grab JSON and exits 0.
+2. Act on the grab (below).
+3. Repeat.
+
+Each grab is also appended to `./.react-grab/history.jsonl` as a durable record;
+the command drops a `.gitignore` there so it never lands in git. `--dir <path>`
+relocates it, `--text-only` skips the native clipboard reader.
+
+## Acting on a grab
+
+The grab JSON has `content` (the element's source references) and, in prompt
+mode, `prompt` (the user's typed instruction):
+
+- **`prompt` present** → that comment IS the task. Execute it against the grabbed
+  source; `content` holds the references (`// path:line`, `in Component (at …)`),
+  so jump straight to that file.
+- **No `prompt`** → apply the standing instruction the user set when starting the
+  loop, or, if there is none, triage it (summarize component + `file:line`) and
+  wait for direction.
+
+A standing instruction is optional; prompt mode lets the user steer each grab
+inline.
+
+## Stopping
+
+When the user says stop, interrupt the command if it is still blocking and do not
+run it again. Confirm the loop has stopped.