doppelhand 1.3.1__tar.gz

doppelhand-1.3.1/CHANGELOG.md

@@ -0,0 +1,61 @@
+# Changelog
+
+## 1.3.1 — 2026-09-09
+
+First release on PyPI: `pip install doppelhand`.
+
+- The Anthropic SDK is no longer installed by default. Only `doppelhand run` talks to an API, so it moved to an extra: `pip install "doppelhand[run]"`. Running it without the SDK now says so instead of raising an import error. The floor is `anthropic>=0.124`, the first version carrying the computer-toolset types.
+- A rotated display falls back to GDI capture. Desktop Duplication hands over the frame in the screen's native orientation, so a portrait monitor would have produced a sideways image whose coordinates disagreed with the desktop rectangle.
+- The source archive now carries the whole test suite, the benchmark and the changelog, so a clean checkout can run what the repository runs.
+- The warning about driving the real mouse and keyboard sits under Install, where someone arriving from the package page will see it.
+
+## 1.3.0 — 2026-09-09
+
+Built for driving a desktop in real time. An action costs about 6ms instead of 300, and a screenshot about 30ms instead of 400.
+
+Measured first: a command that did no work at all cost ~400ms, of which ~300ms was Python starting and importing, while capturing the screen through GDI cost 150-775ms and varied wildly from call to call. Resizing and encoding, the parts that looked expensive, were never more than 50ms together.
+
+- `doppelhand serve` holds one warm process open and answers the same actions over loopback HTTP. Reads are GET, anything that moves the pointer or types is POST, and the arguments keep the names the command line uses. The query string is turned back into a command line and handed to the same parser and the same functions, so the two surfaces cannot drift apart.
+- Screens are captured through DXGI Desktop Duplication, which hands over the frame the compositor already holds instead of asking the system to read the screen back. Held open by the server, a capture costs microseconds rather than hundreds of milliseconds, and an unchanged screen costs nothing at all. Opening a duplication is expensive, so one-shot commands keep using GDI, and any display that refuses duplication falls back to it too.
+- The pointer is composited onto duplicated frames, which arrive without one.
+- `shot --fast` writes JPEG and resizes by box filter, roughly a third of the time for slightly softer text.
+- A shot reports which path produced it in `source`.
+- The argument parser is built once in a long-lived process, which was costing 13ms of every request.
+- Usage errors return an exit code instead of raising, so a bad argument reads the same as any other failure.
+
+The server binds to loopback only, requires a secret it writes to a file in the user's own profile, refuses any request carrying browser headers, and refuses any request whose Host is not loopback, which is what stops a web page reaching it by name.
+
+## 1.2.0 — 2026-09-09
+
+Every display is reachable, the pointer is visible, and a coordinate that misses now says so.
+
+- A point outside the view is refused instead of being clamped to the nearest edge. Clamping meant a scale mistake clicked a screen corner and still reported success, which on Windows 11 is the show-desktop hotspot.
+- Usage errors print the same JSON shape as every other failure, so a caller parsing stdout never has to fall back to reading argparse's prose. They exit 2, while a refused action exits 1.
+- `screen` lists every display, numbered left to right. `--monitor N` picks one and `--monitor all` captures them as a single wide image. Each display has its own view space starting at 0,0, so coordinates stay positive whatever the desktop layout.
+- Screenshots include the mouse pointer, composited in after the capture because a GDI copy never contains it. `shot --no-cursor` leaves it out.
+- `cursor` reports which display the pointer is actually on, not just where it is in the current view.
+- The display of the last shot is remembered along with its size. Moving or unplugging a monitor discards the memory instead of misplacing a click.
+- Input refused by a background desktop is retried after attaching to the input desktop, sending only the events that did not get through.
+
+## 1.1.0 — 2026-09-09
+
+Any AI harness can now use doppelhand as its hands, with no API key and no second model.
+
+- Each action is its own command: `shot`, `screen`, `click`, `move`, `drag`, `scroll`, `type`, `key`, `hold`, `wait` and `cursor`. They print one JSON object and exit non-zero when the action did not happen.
+- `shot` writes a PNG and reports the coordinate space, so the calling agent reads the image with its own tools and answers in the pixels it saw.
+- Coordinates default to the screenshot's space and are scaled back to the display. `--space display` passes real pixels straight through.
+- The size of the last full screenshot is remembered, so a click after a `--max-edge` shot lands in the space that shot was taken in.
+- `install-skill` drops a portable agent skill into Claude Code, opencode, AGY (global or workspace), or any directory given with `--dest`. `--print` writes it to stdout.
+- `run` is unchanged and remains the only path that calls the Anthropic API.
+
+## 1.0.0 — 2026-09-09
+
+First release.
+
+- `doppelhand run "<task>"` drives the desktop from a plain-language instruction, using Claude's computer toolset.
+- `doppelhand shot` saves a screenshot without calling the API.
+- Screen capture through GDI and input through `SendInput`, with no capture or automation dependency.
+- All seventeen toolset actions are carried out: screenshot, zoom, the five click kinds, drag, move, button down and up, cursor position, scroll, type, key, hold key and wait.
+- Coordinates are scaled between screenshot pixels and display pixels, and the process declares per-monitor DPI awareness so the two agree on scaled displays.
+- A run stops when Escape is held, when the step budget runs out, or when the model declines the task.
+- Screenshot history is pruned in batches and a prompt-cache breakpoint follows the newest tool result.

doppelhand-1.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shanewas Ahmed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

doppelhand-1.3.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE README.md CHANGELOG.md
+recursive-include tests *.py
+recursive-include bench *.py

doppelhand-1.3.1/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: doppelhand
+Version: 1.3.1
+Summary: Windows agent that reads the screen and drives the mouse and keyboard like a person would
+Author-email: Shanewas Ahmed <shanewasahmed@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/shanewas/doppelhand
+Project-URL: Issues, https://github.com/shanewas/doppelhand/issues
+Keywords: windows,automation,computer-use,screenshot,agent
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Desktop Environment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pillow>=10
+Provides-Extra: run
+Requires-Dist: anthropic>=0.124; extra == "run"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: anthropic>=0.124; extra == "dev"
+Dynamic: license-file
+
+# doppelhand
+
+A double of you at the keyboard. doppelhand captures the Windows screen and drives the mouse and keyboard: clicking, dragging, scrolling and typing the way a person would.
+
+Use it two ways. Give an AI agent you already have eyes and hands, so it looks at your desktop with its own model and acts through doppelhand. Or let doppelhand drive itself with Claude, using its own key.
+
+## Install
+
+```
+pip install doppelhand
+```
+
+Windows only, Python 3.10 or newer. Pillow is the only dependency; screen capture and
+input go straight through the Win32 API.
+
+**This program moves your real mouse and types on your real keyboard.** It can click
+anything you can click. Run it on a machine where that is acceptable and watch what it
+does. `doppelhand run` waits for confirmation and stops when you hold Escape; the
+single-action commands do what they are told, immediately.
+
+## Give your agent hands
+
+Install the skill into whichever harness you use, and it learns the loop by itself:
+
+```
+doppelhand install-skill claude-code
+doppelhand install-skill opencode
+doppelhand install-skill agy               # global, ~/.gemini/config/skills
+doppelhand install-skill agy-workspace     # this project's .agents/skills
+doppelhand install-skill --dest path/to/skills/doppelhand   # anything else
+doppelhand install-skill --print           # read it first
+```
+
+No API key is involved. The agent takes a screenshot, reads the PNG with its own image tool, and calls back with coordinates. Every command answers with one JSON object and exits non-zero when the action did not happen.
+
+```
+$ doppelhand shot
+{"ok": true, "path": "C:\\Users\\you\\AppData\\Local\\doppelhand\\shot.png",
+ "view": [1280, 720], "display": [1920, 1080], "scale": 0.666667, "space": "view"}
+
+$ doppelhand click 640,360
+{"ok": true, "action": "left_click", "at": [640, 360]}
+```
+
+| Command | What it does |
+|---|---|
+| `shot [PATH] [--region X,Y,W,H] [--monitor N]` | capture, write a PNG, report the coordinate space |
+| `screen` | list the displays and report the coordinate space |
+| `click X,Y [--button] [--count] [--modifiers]` | click, double click, right click |
+| `move X,Y` / `drag X1,Y1 X2,Y2` | move the pointer, or press and drag |
+| `scroll up\|down\|left\|right [N] [--at X,Y]` | scroll |
+| `type "text"` / `key "ctrl+s" [--repeat N]` | type text, press a combination |
+| `hold "shift" 2` / `wait 1.5` | hold a key, or pause |
+| `cursor` | where the pointer is, in both spaces |
+
+Coordinates are the pixels of the screenshot, not of the display; doppelhand scales them back up. A point outside that view is refused rather than clamped, so a scale mistake fails loudly instead of clicking a corner. Pass `--space display` if you already have real display pixels.
+
+Every display is addressable. `screen` lists them numbered left to right, `--monitor N` picks one, and `--monitor all` captures the lot as a single wide image. Each display has its own view space starting at 0,0, so coordinates never go negative. The display and size of the last shot are remembered, so the next command lands in the same space without repeating flags; rearranging or unplugging a monitor discards that memory rather than misplacing a click.
+
+Screenshots include the mouse pointer, which a GDI capture leaves out by default. Turn it off with `shot --no-cursor`.
+
+## Real time
+
+A fresh process costs about 300ms before it does anything, which dominates a session of
+many small actions. Run a server once and talk to it over loopback instead:
+
+```
+doppelhand serve
+```
+
+It prints a port and a secret, and writes both to `%LOCALAPPDATA%\doppelhand\serve.json`.
+Reads are GET, anything that moves the pointer or types is POST, and arguments keep the
+names the command line uses:
+
+```
+curl -sH "X-Doppelhand-Token: $TOKEN" "http://127.0.0.1:$PORT/shot?fast=1"
+curl -sXPOST -H "X-Doppelhand-Token: $TOKEN" "http://127.0.0.1:$PORT/click?at=640,360"
+```
+
+One run of `python bench/benchmark.py` on a three-monitor desktop. The spawned column
+moves a lot with what the machine is doing, so re-measure rather than trusting these:
+
+| action | spawned | served | |
+|---|---|---|---|
+| `cursor` | 309 ms | 5.6 ms | 55× |
+| `screen` | 262 ms | 5.3 ms | 49× |
+| `move` | 262 ms | 5.9 ms | 44× |
+| `shot` | 430 ms | 77 ms | 5.5× |
+| `shot --fast` | 378 ms | 30 ms | 12× |
+
+Most of the screenshot gain comes from capturing through DXGI Desktop Duplication, which
+hands over the frame the compositor already holds. Opening one costs more than a whole
+GDI capture, so it only pays inside the server; one-shot commands keep the GDI path, and
+so does any display that refuses to be duplicated. Every shot reports which it used in
+`source`.
+
+The server binds to loopback only, needs the secret from that file, and turns away any
+request that carries browser headers or names a host other than loopback.
+
+## Or let it drive itself
+
+This is the only path that calls the Anthropic API, the only one that needs a key, and
+the only one that needs the SDK:
+
+```
+pip install "doppelhand[run]"
+export ANTHROPIC_API_KEY=sk-ant-...
+doppelhand run "open the calculator and work out 19% of 4,320"
+```
+
+This loop is covered by tests against a scripted client rather than a recorded live run,
+so treat it as the least proven part of the package.
+
+`run` prints what it is about to do and waits for confirmation. **Hold Escape at any point to stop the run** — the key is checked before every action.
+
+```
+--max-steps N    model turns before giving up (default 30)
+--max-edge N     long edge of the screenshots sent to the model (default 1280)
+--model NAME     defaults to claude-opus-5
+-y               skip the confirmation
+-q               print only the final answer
+```
+
+As a library:
+
+```python
+from doppelhand.agent import Agent
+
+print(Agent(max_steps=10).run("close the notification in the corner"))
+```
+
+## How it works
+
+1. `screen.py` captures a display, through GDI for a one-shot command or through DXGI Desktop Duplication when the server is holding one open, and hands back a Pillow image.
+2. `executor.py` shrinks that image to a 1280-pixel long edge, and scales every coordinate the model returns back up to real pixels.
+3. `inputs.py` drives the mouse and keyboard with `SendInput`. Text is typed as Unicode, so it does not depend on the active keyboard layout.
+4. `cli.py` exposes each of those actions as a command, or `agent.py` runs the whole loop against Claude: send the screen, execute the actions in the reply, send the result, repeat.
+
+In the built-in loop, costs are kept down two ways: one prompt-cache breakpoint moves along with the newest tool result, and screenshots older than the last ten are dropped from the history in batches.
+
+## Limits
+
+- Actions are run against a display as a whole; there is no per-window targeting.
+- Displays are addressed one at a time. `--monitor all` captures them together but scales the result down too far to read.
+- A rotated display falls back to the slower GDI capture, because a duplicated frame arrives in the screen's unrotated orientation.
+- Windows blocks synthetic input to windows running as administrator, so a click on one does nothing.
+- The Escape stop applies to `run`, which checks it before each action. Single commands have already finished by the time you could press anything.
+- The built-in loop is covered by tests against a scripted client, not by a recorded live run.
+
+## Development
+
+```
+pip install -e ".[dev]"
+pytest tests -q
+python bench/benchmark.py
+```
+
+## License
+
+MIT

doppelhand-1.3.1/README.md

@@ -0,0 +1,160 @@
+# doppelhand
+
+A double of you at the keyboard. doppelhand captures the Windows screen and drives the mouse and keyboard: clicking, dragging, scrolling and typing the way a person would.
+
+Use it two ways. Give an AI agent you already have eyes and hands, so it looks at your desktop with its own model and acts through doppelhand. Or let doppelhand drive itself with Claude, using its own key.
+
+## Install
+
+```
+pip install doppelhand
+```
+
+Windows only, Python 3.10 or newer. Pillow is the only dependency; screen capture and
+input go straight through the Win32 API.
+
+**This program moves your real mouse and types on your real keyboard.** It can click
+anything you can click. Run it on a machine where that is acceptable and watch what it
+does. `doppelhand run` waits for confirmation and stops when you hold Escape; the
+single-action commands do what they are told, immediately.
+
+## Give your agent hands
+
+Install the skill into whichever harness you use, and it learns the loop by itself:
+
+```
+doppelhand install-skill claude-code
+doppelhand install-skill opencode
+doppelhand install-skill agy               # global, ~/.gemini/config/skills
+doppelhand install-skill agy-workspace     # this project's .agents/skills
+doppelhand install-skill --dest path/to/skills/doppelhand   # anything else
+doppelhand install-skill --print           # read it first
+```
+
+No API key is involved. The agent takes a screenshot, reads the PNG with its own image tool, and calls back with coordinates. Every command answers with one JSON object and exits non-zero when the action did not happen.
+
+```
+$ doppelhand shot
+{"ok": true, "path": "C:\\Users\\you\\AppData\\Local\\doppelhand\\shot.png",
+ "view": [1280, 720], "display": [1920, 1080], "scale": 0.666667, "space": "view"}
+
+$ doppelhand click 640,360
+{"ok": true, "action": "left_click", "at": [640, 360]}
+```
+
+| Command | What it does |
+|---|---|
+| `shot [PATH] [--region X,Y,W,H] [--monitor N]` | capture, write a PNG, report the coordinate space |
+| `screen` | list the displays and report the coordinate space |
+| `click X,Y [--button] [--count] [--modifiers]` | click, double click, right click |
+| `move X,Y` / `drag X1,Y1 X2,Y2` | move the pointer, or press and drag |
+| `scroll up\|down\|left\|right [N] [--at X,Y]` | scroll |
+| `type "text"` / `key "ctrl+s" [--repeat N]` | type text, press a combination |
+| `hold "shift" 2` / `wait 1.5` | hold a key, or pause |
+| `cursor` | where the pointer is, in both spaces |
+
+Coordinates are the pixels of the screenshot, not of the display; doppelhand scales them back up. A point outside that view is refused rather than clamped, so a scale mistake fails loudly instead of clicking a corner. Pass `--space display` if you already have real display pixels.
+
+Every display is addressable. `screen` lists them numbered left to right, `--monitor N` picks one, and `--monitor all` captures the lot as a single wide image. Each display has its own view space starting at 0,0, so coordinates never go negative. The display and size of the last shot are remembered, so the next command lands in the same space without repeating flags; rearranging or unplugging a monitor discards that memory rather than misplacing a click.
+
+Screenshots include the mouse pointer, which a GDI capture leaves out by default. Turn it off with `shot --no-cursor`.
+
+## Real time
+
+A fresh process costs about 300ms before it does anything, which dominates a session of
+many small actions. Run a server once and talk to it over loopback instead:
+
+```
+doppelhand serve
+```
+
+It prints a port and a secret, and writes both to `%LOCALAPPDATA%\doppelhand\serve.json`.
+Reads are GET, anything that moves the pointer or types is POST, and arguments keep the
+names the command line uses:
+
+```
+curl -sH "X-Doppelhand-Token: $TOKEN" "http://127.0.0.1:$PORT/shot?fast=1"
+curl -sXPOST -H "X-Doppelhand-Token: $TOKEN" "http://127.0.0.1:$PORT/click?at=640,360"
+```
+
+One run of `python bench/benchmark.py` on a three-monitor desktop. The spawned column
+moves a lot with what the machine is doing, so re-measure rather than trusting these:
+
+| action | spawned | served | |
+|---|---|---|---|
+| `cursor` | 309 ms | 5.6 ms | 55× |
+| `screen` | 262 ms | 5.3 ms | 49× |
+| `move` | 262 ms | 5.9 ms | 44× |
+| `shot` | 430 ms | 77 ms | 5.5× |
+| `shot --fast` | 378 ms | 30 ms | 12× |
+
+Most of the screenshot gain comes from capturing through DXGI Desktop Duplication, which
+hands over the frame the compositor already holds. Opening one costs more than a whole
+GDI capture, so it only pays inside the server; one-shot commands keep the GDI path, and
+so does any display that refuses to be duplicated. Every shot reports which it used in
+`source`.
+
+The server binds to loopback only, needs the secret from that file, and turns away any
+request that carries browser headers or names a host other than loopback.
+
+## Or let it drive itself
+
+This is the only path that calls the Anthropic API, the only one that needs a key, and
+the only one that needs the SDK:
+
+```
+pip install "doppelhand[run]"
+export ANTHROPIC_API_KEY=sk-ant-...
+doppelhand run "open the calculator and work out 19% of 4,320"
+```
+
+This loop is covered by tests against a scripted client rather than a recorded live run,
+so treat it as the least proven part of the package.
+
+`run` prints what it is about to do and waits for confirmation. **Hold Escape at any point to stop the run** — the key is checked before every action.
+
+```
+--max-steps N    model turns before giving up (default 30)
+--max-edge N     long edge of the screenshots sent to the model (default 1280)
+--model NAME     defaults to claude-opus-5
+-y               skip the confirmation
+-q               print only the final answer
+```
+
+As a library:
+
+```python
+from doppelhand.agent import Agent
+
+print(Agent(max_steps=10).run("close the notification in the corner"))
+```
+
+## How it works
+
+1. `screen.py` captures a display, through GDI for a one-shot command or through DXGI Desktop Duplication when the server is holding one open, and hands back a Pillow image.
+2. `executor.py` shrinks that image to a 1280-pixel long edge, and scales every coordinate the model returns back up to real pixels.
+3. `inputs.py` drives the mouse and keyboard with `SendInput`. Text is typed as Unicode, so it does not depend on the active keyboard layout.
+4. `cli.py` exposes each of those actions as a command, or `agent.py` runs the whole loop against Claude: send the screen, execute the actions in the reply, send the result, repeat.
+
+In the built-in loop, costs are kept down two ways: one prompt-cache breakpoint moves along with the newest tool result, and screenshots older than the last ten are dropped from the history in batches.
+
+## Limits
+
+- Actions are run against a display as a whole; there is no per-window targeting.
+- Displays are addressed one at a time. `--monitor all` captures them together but scales the result down too far to read.
+- A rotated display falls back to the slower GDI capture, because a duplicated frame arrives in the screen's unrotated orientation.
+- Windows blocks synthetic input to windows running as administrator, so a click on one does nothing.
+- The Escape stop applies to `run`, which checks it before each action. Single commands have already finished by the time you could press anything.
+- The built-in loop is covered by tests against a scripted client, not by a recorded live run.
+
+## Development
+
+```
+pip install -e ".[dev]"
+pytest tests -q
+python bench/benchmark.py
+```
+
+## License
+
+MIT

doppelhand-1.3.1/bench/benchmark.py

@@ -0,0 +1,81 @@
+"""Measure doppelhand two ways: a fresh process per command, and a warm server.
+
+    python bench/benchmark.py
+
+Starts its own server on a spare port, runs each action both ways, prints a table.
+Numbers move with what the desktop is doing, so run it twice before believing a change.
+"""
+
+from __future__ import annotations
+
+import http.client
+import json
+import statistics
+import subprocess
+import sys
+import time
+
+TOKEN = "benchmark"
+
+
+def spawned(argv, rounds=5):
+    times = []
+    for _ in range(rounds):
+        start = time.perf_counter()
+        subprocess.run(argv, capture_output=True)
+        times.append((time.perf_counter() - start) * 1000)
+    return statistics.median(times)
+
+
+def served(port, method, path, rounds=15):
+    times = []
+    for _ in range(rounds):
+        start = time.perf_counter()
+        connection = http.client.HTTPConnection("127.0.0.1", port, timeout=30)
+        connection.request(method, path, headers={"X-Doppelhand-Token": TOKEN})
+        answer = json.loads(connection.getresponse().read())
+        connection.close()
+        times.append((time.perf_counter() - start) * 1000)
+        if not answer.get("ok"):
+            raise SystemExit(f"{path} failed: {answer}")
+    return statistics.median(times), answer
+
+
+CASES = [
+    ("cursor", ["doppelhand", "cursor"], "GET", "/cursor"),
+    ("screen", ["doppelhand", "screen"], "GET", "/screen"),
+    ("move", ["doppelhand", "move", "640,360"], "POST", "/move?at=640,360"),
+    ("shot", ["doppelhand", "shot"], "GET", "/shot"),
+    ("shot --fast", ["doppelhand", "shot", "--fast"], "GET", "/shot?fast=1"),
+]
+
+
+def main() -> int:
+    port = 5677
+    server = subprocess.Popen(["doppelhand", "serve", "--port", str(port),
+                               "--token", TOKEN, "-q"])
+    try:
+        for _ in range(50):
+            try:
+                served(port, "GET", "/health", rounds=1)
+                break
+            except OSError:
+                time.sleep(0.2)
+        else:
+            raise SystemExit("the server never came up")
+
+        served(port, "GET", "/shot", rounds=2)  # let the duplication warm up
+        print(f"{'action':14}{'spawned':>12}{'served':>10}{'speedup':>10}")
+        for label, argv, method, path in CASES:
+            one_shot = spawned(argv)
+            warm, answer = served(port, method, path)
+            print(f"{label:14}{one_shot:10.1f}ms{warm:8.1f}ms{one_shot / warm:9.1f}x")
+        print(f"\nframes came from: {answer.get('source', 'n/a')}")
+    finally:
+        server.terminate()
+        server.wait(timeout=10)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

doppelhand-1.3.1/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "doppelhand"
+version = "1.3.1"
+description = "Windows agent that reads the screen and drives the mouse and keyboard like a person would"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Shanewas Ahmed", email = "shanewasahmed@gmail.com" }]
+keywords = ["windows", "automation", "computer-use", "screenshot", "agent"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Environment :: Win32 (MS Windows)",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Desktop Environment",
+]
+dependencies = [
+    "pillow>=10",
+]
+
+[project.optional-dependencies]
+# Only `doppelhand run` talks to an API. Everything else drives the desktop locally, so
+# the SDK stays off installs that will never use it.
+run = ["anthropic>=0.124"]
+dev = ["pytest>=8", "anthropic>=0.124"]
+
+[project.urls]
+Homepage = "https://github.com/shanewas/doppelhand"
+Issues = "https://github.com/shanewas/doppelhand/issues"
+
+[project.scripts]
+doppelhand = "doppelhand.cli:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+packages = ["doppelhand"]
+
+[tool.setuptools.package-data]
+doppelhand = ["skill/SKILL.md"]

doppelhand-1.3.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

doppelhand-1.3.1/src/doppelhand/__init__.py

@@ -0,0 +1,20 @@
+"""doppelhand — read the Windows screen, drive the mouse and keyboard."""
+
+from doppelhand.errors import (
+    ActionError,
+    Aborted,
+    DoppelhandError,
+    Refused,
+    StepLimit,
+)
+
+__version__ = "1.3.1"
+
+__all__ = [
+    "ActionError",
+    "Aborted",
+    "DoppelhandError",
+    "Refused",
+    "StepLimit",
+    "__version__",
+]