332 Commits

Author	SHA1	Message	Date
Ignacy Łątka	cee2d69a4f	test(flows): point the scope-snippet doc test at references/selectors.md	2026-07-27 22:04:20 +02:00
Hubert Gancarczyk	5ac69349f0	feat(flow): CSS combinator scopes for flow selectors (#569) ... ## What Adds the CSS combinators to flow selectors, read off frames. Any action or condition can now scope its matches by where an element sits relative to another: ```yaml - tap: { text: Delete, within: { id: profile-card } } # CSS "A B" — inside that container - tap: { role: Switch, next: { text: Wi-Fi } } # CSS "A + B" — the nearest follower - assert: { visible: { role: Button, after: { text: Danger zone } } } # CSS "A ~ B" — any follower - assert: { hidden: { any: true, within: { id: empty-state } } } # CSS "*" — the universal selector ``` | Scope | CSS | Reads as | | --- | --- | --- | | `within: <sel>` | `A B` | the match's frame sits inside the scope element's frame | | `after: <sel>` | `A ~ B` | the match follows the scope element in reading order | | `next: <sel>` | `A + B` | as `after`, narrowed to the nearest follower of each anchor | Plus `any: true` — the CSS `*` universal selector, accepted only alongside a scope and never beside `text`/`id`/`role`. The child combinator `>` has deliberately **no analog**: flow trees flatten to leaves under one synthetic root, so parent/child structure does not survive to replay. ## How - **Geometric, not ancestry-based.** Frames are what survives flattening, so every scope is resolved from them by `findAll` in `ui-tree-match`. The synthetic root never counts as a scope element, and every relation requires a *distinct* node (nothing scopes itself). - **Reading order is row-band aware.** An element follows the anchor when it starts below the anchor's bottom edge, *or* shares its row band and sits entirely to its right. That band rule is what makes `{ role: Switch, next: { text: Wi-Fi } }` resolve the Wi-Fi row's own switch even though the taller switch's frame starts a couple of pixels *higher* than the label's — a raw top-y comparison gets that backwards. `followKind` is the single classification both the follower test and the nearest-pick grouping read, so they cannot disagree. - **`next` is the union over anchors**, exactly as CSS `A + B` is: three rows on screen give three switches, one per label. - **Scopes compose and nest**, capped at `MAX_SELECTOR_SCOPES` (6) counted across the whole relation *tree* — a size bound, not a depth bound, because three relations branch and the runner's loose-alternative expansion is exponential in the bare-string scopes it finds. - **Flow-YAML only.** `await-ui-element`'s strict schema rejects `within`/`after`/`next`/`any`, so a scope can never be silently dropped on that path. - Adding a fourth relation is a **compile error**: `RELATION_RESOLVERS` is a `Record` keyed by the relation union, so a new scope cannot be wired through parse/serialize/reporting and then ignored by the match engine. ## Testing - **Unit:** full tool-server suite green — **3006 passed / 1 skipped**. New coverage in `ui-tree-match.test.ts`, `flow-utils.test.ts`, `flow-selector-scopes.test.ts` (renamed from `flow-within-selector.test.ts`, now covering all scopes) and a new `flow-skill-docs.test.ts` that parses every YAML snippet in the skill so the docs cannot rot. Each fix is mutation-checked: reverting it fails at least one test. - **Real-device E2E** (Pixel 3a, Bluesky on Metro 8081, via a branch tool-server): three flows, 20 steps, all green — geometric ordering both ways, two `text` asserts that pin `next`'s pick *by identity* out of five candidates, empty-scope `hidden` semantics, and two observable taps (`next`-scoped and `any: true`-scoped) that navigated to the *adjacent* topic rather than the anchor's own. - **iOS not covered.** Native-devtools does not attach on either booted simulator in this environment, so *every* flow selector fails there — an unscoped `{ text: "Video" }` fails identically. Verified environmental, not caused by this branch: the globally-installed argent reports the same, direct `SIMCTL_CHILD_DYLD_INSERT_LIBRARIES` injection also fails to connect, and it survives a forced simulator reboot on both iOS 18.3 and 26.5. Worth re-running the iOS leg once that is healthy. ## Notes for reviewers Two deliberate deviations from CSS, both documented in the skill: - **`next` is looser than `+`.** Where `A + B` matches nothing unless the immediate sibling is a `B`, `next` keeps looking and returns the nearest match further on. That is what makes it survive the wrapper and spacer nodes a flattened tree is full of — but a row *missing* the control you asked for resolves to the next row's rather than failing. Happy to switch to strict `+` semantics if the loud failure is preferred. - **"follows" is not transitive.** Against a tall anchor an element can follow something that follows the anchor without following it directly, so nesting `after` scopes is not the same as chaining `~`. Other things worth a look: - `nearestAfter` and `afterTester` are direct scans, not indexed. An earlier sorted index was a *second* implementation of the nearest rule and the two disagreed on frames near the tolerance; it also measured 2-13x slower than the scan on realistic shapes, with a prune that provably never fired. The quadratic tail is documented with measured numbers: 1.2 ms for a single-anchor `next` at the 12k-node tree cap, ~555 ms only when the anchor selector matches essentially every node. - A bare-string *anchor* cannot self-correct the way the loose fallback usually does — a decoy `testID` matching your anchor text wins the identifier pass whenever anything sits after it. The skill tells authors to spell sibling anchors as maps. - `MAX_SELECTOR_SCOPES = 6` replaces the previous `MAX_SELECTOR_WITHIN_DEPTH = 10`, so a `within` chain deeper than 6 that parsed on the earlier commits of this branch now rejects. Nothing released depends on it. --------- Co-authored-by: Hubert Gancarczyk <claude-hubert.gancarczyk@swmansion.com>	2026-07-27 18:25:27 +02:00
Jakub Piasecki	e23f0e285e	feat(flow): snapshot cropOn for single-element visual diffs (#516) ... `snapshot` gains an optional `cropOn: <selector>` — diff one element's region instead of the whole screen: `- snapshot: { name: cart-total, cropOn: "Order summary" }` - The selector resolves like a directive target: settled tree, auto-wait, the standard not-found failure. Selector-only — no point form (a point has no extent to crop to). - The frame resolves **before** the capture, and the **cropped** image is what gets compared, stored as the baseline, and reported as the `current` artifact. The pixel rect is the normalized frame × capture size; the crop is a pngjs `bitblt` written to a swept scratch dir and registered only when a failure returns it. - The baseline key stays on the **full** capture's WxH (device-class identity), so the previously unreachable `dimensionMismatch` guard becomes load-bearing: an element that grew or shrank fails with "nothing was compared" plus a crop-fixed-size-containers hint. Deliberately strict — a 1px layout drift fails on dimensions, not content (the same tradeoff as Playwright element screenshots). - A tree-source outage while resolving `cropOn` errors the step instead of degrading to a full-screen compare against a cropped baseline. - No tool-schema changes; `snapshotKey` and `--output` behavior ride along unchanged. Tests: parse/serialize round-trip + rejection cases, and runSnapshot coverage with real PNGs (crop dims, key vs. content, artifact retention/sweep, unresolved selector, abort, size-drift message, sub-pixel region).	2026-07-27 10:07:49 +02:00
Jakub Piasecki	6a53e66a96	feat(flow): rotate directive (#546) ... # feat(flow): rotate directive Adds a selector-targeted two-finger rotation directive to flows: `rotate: { on?, by }`. `on` resolves like `tap` (settled tree + auto-wait); omitted, the rotation centers on the screen. `by` is degrees, positive = clockwise. Distinct from `tool: rotate`, which changes device orientation — the docs and step labels call this out. ## Design **One continuous gesture, fixed pace, no duration option.** Fingers orbit at ~90°/300 ms; duration derives from the angle. Unlike pinch there is no sub-gesture chaining — any angle dispatches as one sweep, so the angular delta is exact with no settle delays. `by` is parse-bounded to ±3000°: the largest sweep the 10 s single-gesture envelope delivers at that pace, derived from the constants rather than picked as policy — rejected at parse, never silently clamped. A consequence embraced here: frame count always scales with the angle, so a speed-sensitive recording stays a raw `tool:` step (the create-flow skill's polish list covers the conversion). **Fixed centroid, constant physical radius.** Drifting the centroid would couple pan into the turn; growing the radius would couple pinch. Both stay fixed — the trade is a smaller orbit near edges and small targets, in exchange for a pure rotation. **Physical circle, not a normalized-space ellipse.** A single normalized radius on a non-square screen traces a physical ellipse, coupling an unintended pinch into every turn. `gesture-rotate` grows optional per-axis `radiusX`/`radiusY` (fractions of width/height with `radiusX·W = radiusY·H`), and the flow tree adapters surface screen dimensions via an optional `screen` field on `DescribeTreeData` so the directive can compute the aspect. Missing dimensions fail soft to the legacy single-radius call rather than erroring. **Placement reuses pinch's edge model.** The initial finger axis (horizontal or vertical) is scored against the same per-platform system-edge guards, preferring a start parallel to the nearest violated edge and staying inside the target's axis-matching span. Guards only score placement — they never shrink the radius, and a violated guard is attempted, never rejected. The only geometry failure is no positive on-screen orbit radius. **Abort correctness.** `gesture-rotate` now honors `ctx.signal`: each frame checks it, lifts the synthetic fingers with a terminal Up (so a cancelled run doesn't leave them held on the glass), then throws with name `AbortError`; the directive maps a mid-gesture abort to the run's aborted skip rather than a step failure. **Explicit `inputSchema`.** The radius requirement is a zod `.refine()` cross-field rule, which `z.toJSONSchema` drops — so the tool ships a derived schema plus an explicit `anyOf` (`radius` or `radiusX`+`radiusY`) to keep invalid calls rejected at the schema layer. **Platform rejections.** Vega is remote-driven (no touch) and Chromium has no rotate-gesture idiom at all — both fail upfront with guidance to drive the app's rotate controls directly. ## Tests Unit tests cover the geometry module (duration derivation, candidate construction, aspect handling, edge-guard ranking), the directive end-to-end against a fake device, and `gesture-rotate`'s per-axis radii and abort path.	2026-07-24 13:18:23 +02:00
Ignacy Łątka	a0460eeefe	chore: bump workspace packages to 0.17.0 (#554) ... ## What Lockstep-bump all 16 `packages/*` workspace packages (and the matching `package-lock.json` entries) from `0.16.1` → **0.17.0**. Diff is exactly 32 version-field swaps across 17 files — no formatting or dependency churn. ## Verification - **Lockfile CI gate reproduced locally on the exact CI toolchain** (Node 24.14.1 / npm 11.11.0, matching `lockfile.yml`'s `node-version: "24"`): `npm install --package-lock-only --ignore-scripts` on top of the commit, then `git diff --exit-code -- package-lock.json` → **clean**. npm's own regeneration reproduced the hand-edit byte-for-byte, so none of the `"peer": true` churn that #513/#539 had to keep out reappears here. - `node scripts/check-workspace-versions.mjs` → `All workspace packages are at 0.17.0.` - Remaining `repo-hygiene.yml` checks pass: no conflict markers, no focused tests. - `prettier --check` on all 17 changed files → `All matched files use Prettier code style!` - **Runtime version actually reports 0.17.0**: `getInstalledVersion()` (`argent-installer/src/utils.ts:384`) and `getGloballyInstalledVersion()` (`topology.ts:94`) both read `version` straight out of the resolved package root's `package.json` at runtime, so the bump is the whole mechanism — no generated constant or second version file to keep in sync. Exercised that resolution against the bumped tree: `PACKAGE_ROOT` → `packages/argent` (`@swmansion/argent`) → `0.17.0`. - Verified all 16 lockfile hits belong to workspace packages (parsed the lockfile's `packages{}` and matched every `0.16.1` entry to a `packages/*` path) — no unrelated dependency happened to sit at 0.16.1. - No test asserts a release version string; the only `0.1x.x` matches under `*.test.ts` are historical references inside comments. ## Note `packages/argent-private` needs no pin change here. Its release version is carried purely as a git tag — the repo has no version field on the release line (its only `package.json` is a `private: true` research CLI on an independent `0.1.0` line) — and `v0.17.0` is now tagged at `2d6c292`, which is **already** the commit this superproject pins. `v0.16.0` and `v0.16.1` sit on that same commit, so the submodule entry is correct as-is and stays out of this diff.	2026-07-23 23:33:49 +02:00
Ignacy Łątka	98ae93145b	feat(screen-recording): save recordings to the project's .argent/recordings (#551) ... Stacked on #549 (touch visualizer). ## What Screen recordings now land durably under **`.argent/recordings/`** on the client, instead of the disposable temp-artifact cache — and for a remote `argent link` tool-server they land on the **client** host, not the server. ## Why Two rough edges in the recording flow: 1. The finished video was only ever written to the OS temp-artifact cache, so it was easy to lose and not obviously part of the project. 2. Over `argent link`, the video was downloaded into that same temp cache; there was no project-scoped home for it. ## How - New optional `saveDir` hint on the artifact wire contract (`@argent/registry` + `@argent/tools-client`). - `screen-recording-stop` tags its video with `saveDir: ".argent/recordings"` and drops the internal `argent-` temp prefix from the filename. - The client materializer honours `saveDir`: **copies** the file when the tool-server is co-located, **downloads** it over `/artifacts/:id` when it is remote. Either way the bytes end up in the durable directory. - `saveDir` resolves against the client's **project root** (nearest ancestor with `.git`/`package.json`/`.argent`), falling back to the global **`~/.argent`** when run outside a project — matching how the rest of argent scopes per-project config. Adds `findProjectRoot` to `configuration-core` (a null-returning variant of `resolveProjectRoot`) to drive that choice. - Hardened: absolute paths and `..` escapes are rejected, directory bundles excluded — a tool-server can't steer a write outside the base directory. ## Verification - Unit: 28 cases in `argent-tools-client/test/artifacts.test.ts` (co-located copy, remote download, project-root anchoring incl. from a subdirectory, global fallback, path-traversal rejection, integrity). configuration-core suite green (55). - E2E against a booted iOS 18.5 sim + a worktree tool-server, driving the real client materializer path: - in a project, co-located server → `<projectRoot>/.argent/recordings/…mp4` (valid h264) - in a project, forced remote download (`GET /artifacts/:id`) → same durable dir, temp cache left empty - outside a project (HOME redirected) → `~/.argent/recordings/…mp4` - Root `tsc --build`, prettier, and eslint all clean. MoQ / `sim-remote` recording support lands in a separate PR stacked on this one. --------- Co-authored-by: Ignacy Łątka <claude-hubert.gancarczyk@swmansion.com>	2026-07-23 22:43:01 +02:00
Ignacy Łątka	f85d3843aa	feat(screen-recording): draw touch gestures into the recording (#549) ... ## What Draws the touch gestures argent drives directly into the screen recording, so a captured video shows **where** each interaction landed instead of a UI reacting to an invisible finger: - a pulse marks each **tap** - a fading comet trail follows a **swipe / drag** - paired markers show the two contact points of a **pinch / rotate** On by default; pass `showTouches: false` to `screen-recording-start` for a raw, overlay-free capture. ## How simulator-server already has a touch visualizer behind its `pointer` cargo feature (the binary argent bundles ships with it). It renders the markers into the very MJPEG stream this recording pipeline already consumes — nothing is composited host-side, and it's driven by the touch events argent already sends. This PR just turns it on for the life of a recording: - `screen-recording-start` builds a small `PointerControl` from the resolved simulator-server handle and hands it to `startCapture`. - The overlay is enabled right after the encoder goes live (so the first interaction is already drawn) and **restored to off** when the capture ends — stop, time-limit cap, encoder crash, or session teardown all run the same disable path, so it never outlives the recording it was enabled for. - Two thin client helpers (`setPointerVisible`, `setPointerTrail`) POST to simulator-server's `/api/pointer`. They're best-effort: a build without the feature (or a remote sim) just yields a `warning` at stop and a normal overlay-free video, never a failed recording. ## Verification - **Unit** — `screen-recording.test.ts`: 49 pass, incl. 10 new covering enable-at-start / disable at stop, cap, unexpected exit, and dispose; the `pointerFailed` warning; the no-control path; and the `/api/pointer` wire format (`{show}` / `{trail}`, ok/error/throw handling). - **Static** — `tsc` (src + `tsconfig.test.json`), eslint, prettier, full workspace build all clean. - **E2E** — drove the real tool-server → the bundled (production) simulator-server on an iOS 18.5 sim: - `showTouches: true` + a slow swipe → a translucent pointer bubble is rendered onto the screen at the touch point in the recording. - identical swipe with `showTouches: false` → paging still happens, **no bubble** — proving both the toggle and that stop restored the overlay to off (the control clip never re-enables it, yet draws nothing). --- Stacked on #548 (static-frame trimming) → base branch `feat/screen-recording-trim`. Review after that merges. --------- Co-authored-by: Ignacy Łątka <claude-hubert.gancarczyk@swmansion.com>	2026-07-23 22:32:51 +02:00
Ignacy Łątka	82f6eb16b0	feat(screen-recording): trim static stretches out of the recording (#548) ... > Stacked on #517 (`feat/screen-recording`). Review/merge that first; this PR's diff is against that branch. ## What Trims stretches where the screen doesn't change out of the recorded video. A recording left running across waits, slow navigation, or agent thinking time used to come back padded with dead air; now a long session with only brief activity comes back as a short clip. ## How The frame pump already re-emits the last frame on a wall-clock schedule to keep the timeline honest. This adds a change detector on top: - Each frame is compared to the last one **byte-exact** (a reference check short-circuits the common "no new frame arrived" case, so only genuine arrivals pay the compare). Exact byte equality is stronger than a hash — no collisions — and flags a change down to a single pixel, matching "something moved, even by a couple of pixels." - The first second of every still stretch is kept (pauses read naturally), then unchanged frames are dropped until the screen moves again. - Active stretches still play at real time: the wall-clock pacer is re-anchored whenever a dead stretch is skipped, so the gap yields no output frames rather than a catch-up burst of the next frame. On by default. `trimStatic: false` on `screen-recording-start` keeps a faithful real-time recording (e.g. to measure how long something took on screen). `screen-recording-stop` now returns the trimmed length as `durationMs`, plus `wallClockMs` and `trimmedMs` when trimming removed anything. ## Verification - **Unit**: 39 tests in `screen-recording.test.ts` (7 new trim cases: default-on, grace-window kept, no-trim control, resume-the-moment-the-screen-changes, byte-identical-new-frame-stays-trimmed, duration reporting, fields-omitted-when-off). Full tool-server suite green (2817). `tsc --build`, `typecheck:tests`, eslint, prettier clean. - **E2E on a live tool-server (iOS 18.6 sim)**: - 23s idle-heavy session (motion → 15s idle → motion) → **1.47s** clip, `trimmedMs` 21930, with the real transitions intact (44 distinct frames — above the 30-frame grace floor, proving post-grace motion is kept). A `trimStatic:false` control of the same pattern returned the full 23s / 691 frames. - 8s continuous burst-motion session → **2.1s** across multiple motion bursts (not collapsed to the 1s floor). - **Cross-check**: ran ffmpeg's own `mpdecimate` (duplicate-frame detector) over the same untrimmed footage — it kept ≤ what this trim keeps, confirming the trim is faithful, never over-aggressive (byte-exact is deliberately more conservative than mpdecimate's near-duplicate heuristic, so smooth animation is preserved while only frozen stretches are dropped).	2026-07-23 21:45:42 +02:00
Ignacy Łątka	2251c7cf46	feat(screen-recording): screen-recording-start/stop tools with per-call stop reminders (#517) ... ## What Adds a `screen-recording-start` / `screen-recording-stop` tool pair (naming follows `native-profiler-start/stop`) that records the device screen to an mp4 and returns it as a downloadable artifact. Capture runs through **simulator-server** — the same backend `screenshot` and every interaction tool already drive. simulator-server publishes the device screen as an MJPEG stream (`/stream.mjpeg`), so recording needs no platform-specific recorder: the tool-server subscribes to that stream, paces the frames onto a fixed 30 fps timeline, and pipes them into a single ffmpeg process that encodes — and watermarks — straight to the final mp4. The stream is multi-subscriber, so a preview window can stay open on the same device while recording. - **One path for every device simulator-server drives** — iOS simulators, Android emulators, and physical Android devices. - **Native resolution, constant 30 fps** — h264, `+faststart`, no post-processing pass. - Session state lives in a per-device `ScreenRecordingSession` blueprint (mirrors the native-profiler session): time-limit cap with auto-finalize, unexpected-exit recovery (a capture that ended on its own is still retrievable via stop), always-startable state reset on stop, and dispose-on-shutdown cleanup through the registry. ## Why the frames are paced host-side A device only emits a frame when the screen **changes**. Pointing ffmpeg straight at the stream therefore produces a video whose length is the sum of the moments something moved — a still screen collapses to a fraction of a second — and an ffmpeg blocked on a silent socket does not answer a stop signal promptly either (measured: 12 s late). Re-emitting the last frame on a wall-clock schedule fixes both: **video duration always equals real elapsed time**, and stop is a stdin EOF that finalizes in ~60 ms. Duplicate frames cost almost nothing once encoded (a 10 s recording of a static screen is ~1 MB). ## Finishing pass folded into capture The Argent watermark (logo + `By @swmansion`, bottom-left, sized relative to the frame) is stamped by the same ffmpeg invocation that encodes the capture, so there is no second encode and no temp intermediate. Its colour is chosen **per pixel** from the background luma underneath it — the white logo over dark areas, a runtime-derived near-black copy over light areas — so it keeps maximum contrast against whatever is behind it. It sits at 20 % opacity and is opt-out via `argent disable video-watermark` (read when the recording starts). Frame geometry comes from the first JPEG's SOF header, so no `ffprobe` is needed. ffmpeg is now the recorder rather than an optional finisher, so a missing ffmpeg fails `screen-recording-start` up front with an install hint instead of silently degrading the output at stop time. ## Reminder plumbing While a recording is running — or ended on its own but was never retrieved — **every** tool result carries a `note` telling the agent the recording is still going and how to stop it. It rides the same `note` field as the update reminder but is per-call and unsuppressed; both notes compose when they coincide. The note text switches to "already ended, retrieve the file" once the cap fires or the capture dies. ## Skill New `argent-screen-recording` skill (+ routing stanza in `rules/argent.md`): documents the start → interact → stop workflow and instructs the agent to schedule its own reminder/wakeup for the expected end of the recording immediately after starting one (harness reminder tool if available, otherwise a background `sleep` whose completion notification pulls it back). Scores 10/10 on `scripts/grade-skills.mjs`. ## Verification - Unit: 45 tests across `screen-recording.test.ts`, `mjpeg-stream.test.ts`, `watermark.test.ts`, `http-recording-note.test.ts`; full tool-server suite **2808 tests / 280 files green**; `tsc --noEmit -p tsconfig.test.json`, root `tsc --build`, eslint, prettier all clean. - E2E on a live tool-server (`POST /tools/...`), driving real interactions between start and stop: - **iOS sim** (iPhone 16 Pro Max, iOS 18.5): 1320×2868 h264, `r_frame_rate=30/1`, 338 frames, container duration 11.27 s vs reported `durationMs` 11314 — **within 50 ms of wall clock**. Extracted frames show real screen content (mid app-switcher animation) with the watermark rendered light-over-dark. - **Android emulator** (Pixel 3a, API 34): 1080×2220 h264, 30 fps, 353 frames, duration 11.77 s vs `durationMs` 11793 — within 30 ms. 512 KB for a mostly-static home screen. - **Static screen** (no interaction at all, 10 s): 300 frames, duration exactly 10.000 s — the case the previous `recordVideo` implementation reduced to ~0.03 s. - **Long silence then activity** (15 s untouched, then an app launch): stream survived, no warning, frames after the silence show the new screen. This caught a real bug during review — the connect timeout was also acting as a socket *inactivity* timeout and tore the stream down at 10 s of stillness; fixed and covered by a regression test that fails without the fix. - **Time-limit cap**: `timeLimitSeconds: 5` self-finalized at 4.97 s / 149 frames, the per-call note flipped to "already ended (it hit its 5s time limit)", and a stop issued 11 s later still returned the video with the matching warning. ## Not supported (capability-gated with clear errors) tvOS simulators, physical iPhones, Chromium apps, Vega, and remote (`remote:`-prefixed) simulators — none of them expose a readable frame stream. --------- Co-authored-by: Ignacy Łątka <claude-hubert.gancarczyk@swmansion.com>	2026-07-23 21:14:37 +02:00
Aayush Gautam	3795cb84fb	fix(ios-profiler): stop native-profiler-stop being aborted mid-packaging (#529) ... ## Problem `native-profiler-stop` fails with `No active native profiling session found. Call native-profiler-start first.` while xctrace is still recording — #248, #250, #330. Those were closed on the 0.12.1 `--all-processes` workaround (#380), which fixed trace finalization but not this. The tool isn't declared `longRunning`, so the MCP adapter applies its per-request timeout: ```js fetchTimeoutMs: meta?.longRunning ? null : FETCH_TIMEOUT_MS, // mcp-server.ts:222 ``` A stop that runs past 30s is aborted and retried (`MAX_RETRIES = 4`). The retry runs against the session state the first call has already cleared, hits the `!api.profilingActive` branch and throws. The message points at session tracking; the actual failure is the timeout. Every failed stop I have logs for lands at 30–34s: `durationMs: 33639` in [#330](https://github.com/software-mansion/argent/issues/330), and 30276 / 30605 / 31019 / 31914 locally. Stop can't fit in 30s on Xcode 26.4+. Since #380 the capture is host-wide rather than app-scoped, so the bundle is much larger — ~55MB per 10s of recording here, 385MB for 90s — and xctrace needs ~22s to package even the 10s case before the four export passes start. `STOP_GRACE_MS` has the same problem from the other side: at 30s xctrace is SIGTERM'd mid-package, and the bundle it leaves behind fails to export. ## Fix Declare the tool `longRunning`, and raise `STOP_GRACE_MS` to 300s. The grace is a ceiling rather than a fixed wait — a fast package still returns as soon as xctrace exits — so this only changes captures that were previously killed. With both applied a 90s capture stops and exports cleanly in ~2–4 min, and a 40s capture returns inline. ## Note The abort-and-retry sequence is inferred rather than captured directly. What's observed: `MAX_RETRIES = 4`, the uniform ~30s durations, and `tool-server.log` showing the `did not respond to SIGINT` warning — written after the throw site — logged 184ms *before* the failure was returned. One execution can't produce that ordering. ## Testing - `npm run build` and eslint clean on changed files - `npm test -w @argent/tool-server` — 2727 tests / 273 files pass - Verified on Xcode 26.5 / iOS 26.5 simulator against a bridgeless RN app: start → interact → stop → analyze now returns a populated report with `errors: {}`	2026-07-23 18:32:44 +02:00
Jakub Piasecki	e006e68c81	fix(tool-server): tag gesture-pinch/gesture-rotate as ios/android in run-sequence (#541) ... Both gestures appear to be supported on Android: https://github.com/software-mansion/argent/blob/5d3f7bc62b278c03f3e63b45387cb41b937185c9/packages/tool-server/src/tools/gesture-pinch/index.ts#L54 https://github.com/software-mansion/argent/blob/5d3f7bc62b278c03f3e63b45387cb41b937185c9/packages/tool-server/src/tools/gesture-rotate/index.ts#L44	2026-07-23 08:02:00 +02:00
Jakub Piasecki	f32659df31	feat(flow): pinch directive (#545) ... Adds a selector-targeted pinch-zoom directive to flows: `pinch: { on?, scale }`. `on` resolves like `tap` (settled tree + auto-wait); omitted, the pinch centers on the screen. `scale > 1` zooms in, `< 1` zooms out. ## Design **Options-map only, no bare form.** `tap: "Map"` is unambiguous; `pinch: "Map"` isn't (in or out?), so the parser requires `{ on?, scale }` and rejects a bare selector with authoring guidance. **Validity checks, not policy caps.** `scale` must be finite, > 0, and ≠ 1 (a no-op scale is almost certainly a mistake) — but there is deliberately no magnitude cap. An extreme scale decomposes logarithmically into equal-ratio sub-gestures of ≤4× each, chained with a 250 ms recognizer-reset delay (`scale: 1e6` is just 10 gestures). **Pure geometry module.** All placement math lives in `flow-pinch-geometry.ts` as deterministic data-in/data-out functions (no device access), so tests drive it with synthetic centers, spans, and edge guards. Per sub-gesture, a horizontal and a vertical candidate are built from the axis-matching target dimension (normalized X and Y are different units, so never `min(width, height)`), and the better one is dispatched. **Edge safety scores, it never rejects.** Per-platform system-edge guards (wider on Android's back-gesture zones) demote candidates in ranking but never fail a step: viable travel beats edge safety (a risky-but-perceptible gesture beats a safe no-op the recognizer ignores), then fully-safe with the most travel, then motion parallel to the violated edge (edge swipes need motion *away* from the edge). Guards are resolved once per directive and passed as data — the seam for a future per-device query. The only geometry failure is literally zero on-screen finger travel; a tiny target is still attempted. **Centroid drift near edges.** When expanding fingers would leave the screen, the centroid drifts inward — only on the moving axis, and only as far as needed. `gesture-pinch` grows optional `endCenterX`/`endCenterY` to interpolate the centroid alongside separation; omitted, behavior is unchanged. **Open-loop by design.** There is no "current zoom" to read back, so the directive doesn't try to verify the multiplier — flows assert on the resulting UI instead. **Platform rejections.** Vega is remote-driven (no touch input) and Chromium has no uniform pinch-zoom mapping for a desktop app (ctrl+wheel or app-specific controls) — both fail upfront with guidance to drive the app's zoom UI directly. ## Tests Unit tests cover the geometry module (decomposition, candidate construction, edge-guard ranking), the directive end-to-end against a fake device, and the `gesture-pinch` centroid-drift interpolation.	2026-07-23 07:44:26 +02:00
Ignacy Łątka	87a7e77c1f	fix(tool-server): remove self-referential node_modules symlink committed in #476 (#537) ... ## What `packages/tool-server/node_modules` is tracked in git as a **self-referential symlink** — mode `120000`, target `/Users/.../packages/tool-server/node_modules` (it points at itself). It was introduced in `300bc30e` (#476) and is the only tracked `node_modules` in the repo; sibling packages have plain empty dirs. Every clone/pull of `main` now materializes a circular **ELOOP** link that breaks any recursive directory walker (`find`, globbers, bundlers, backup tools). Runtime is unaffected — deps hoist to the root `node_modules`, so the loop is silently bypassed. ## Why it slipped past `.gitignore` The `node_modules/` and `packages/*/node_modules/` rules have a **trailing slash → directories only**. Git treats a symlink as a file (blob), so neither rule matched and the path was addable → it rode into #476. `git check-ignore` confirmed it was NOT ignored. ## Fix - Remove the tracked self-symlink. - Drop the trailing slash on both ignore rules so a `node_modules` of **any** type (dir, file, or symlink) is ignored — verified with `git check-ignore` that a symlink at `packages/*/node_modules` is now refused. No runtime code touched.	2026-07-22 19:59:25 +02:00
filip131311	7f85f996aa	fix(tool-server): defer to an existing server on EADDRINUSE instead of crash-looping (#533) ... ## Summary Fixes **bucket B** of the 0.16.0 crash telemetry — the `toolserver_bind` / `EADDRINUSE` restart loop. It's the largest crash **volume** (~817 events, one machine alone = 785) even though it's a narrow user set (10). Companion to #531 (which fixed the widespread multi-user bucket A). ## Root cause (reproduced live) The main HTTP listener's `server.on("error")` handler routed **every** bind error through `crashShutdown` (exit 1). When a second tool-server starts on an already-owned port, that exit just feeds a supervisor respawn → re-bind → crash, forever. The telemetry signature was puzzling: all these crashes are `crash_phase=serving` with ~1s uptime and **0 tool calls** — i.e. the listener *bound successfully* and then died. I reproduced it: on macOS, a **second tool-server process's** `listen()` momentarily **succeeds** (the `listening` callback runs → `listening=true` → phase `serving`), and **then** the server emits an asynchronous `EADDRINUSE`. So the redundant instance binds, immediately errors, crashes, and the supervisor loops it (~1s each, 785× on one machine). Live A/B on the compiled `dist` (isolated port, telemetry disabled), server A up then a second server B on the same port: ``` buggy (current 0.16.0): B: "Tools server listening ..." → "Failed to bind ... EADDRINUSE" → exit 1 (→ respawn loop) fixed: B: "Tools server listening ..." → "deferring to it (redundant instance)" → exit 0 ``` A survives in both. ## Fix Handle `EADDRINUSE` specifically instead of crash-looping: - Probe the port for a healthy argent tool-server (`GET /tools` → 200, or 401 when a token is configured). - **If a healthy peer answers**, this instance is redundant → shut down **cleanly** (`shutdown(0)`) and defer to it. This removes it from the `reason:"crash"` restart-loop population entirely. - **If nothing healthy owns the port** (a foreign holder, or a wedged peer that doesn't answer within the probe timeout) → still crash, so a genuinely stuck port stays visible. - `EACCES` and all other server errors crash exactly as before. It also corrects the now-false comment claiming these crashes are phased `startup` ("the listen callback never ran"). Telemetry and the live repro prove the bind succeeds first, so `listening=true` and the phase is genuinely `serving`. ## Testing - **New unit tests** for `probeArgentToolServer`: peer answering 200 or 401 → `true`; foreign 500, connection-refused, and wedged/timeout → `false`. - Full tool-server suite **2731 green**; `tsc` + `eslint` clean. - **Live A/B** above, on the built dist. ## Note on scope This is a robustness fix that breaks the loop for the redundant-instance case (the dominant one). The precise reason macOS lets a second process's bind succeed-then-error asynchronously (vs. failing immediately, as same-process contention does) is a kernel/loopback timing detail; the fix does not depend on it — any `EADDRINUSE`, immediate or deferred, now defers-or-crashes deterministically rather than hot-looping.	2026-07-22 16:56:54 +02:00
Ignacy Łątka	7400179b5b	Windows support: Android + Chromium host control plane (#421) ... ## What Makes Argent run on Windows. iOS Simulator is macOS-only (Apple), so on Windows that means the **Android + Chromium** host control plane. The blocker was twofold: (1) no Windows `simulator-server` binary, and (2) POSIX-only assumptions in the tool-server. Companion radon PR builds the binary and runs the Android emulator E2E on Windows: software-mansion/radon#134. ## Changes **Windows-aware tool-server / resolver / bundling** - New shared `commandOnPath()` helper — `where` on Windows, `command -v` via `/bin/sh` on POSIX. `android-binary`, `check-deps`, and `vega-cli` previously hardcoded `/bin/sh`, which never matches on Windows. - `android-binary`: append `.exe` to `adb`/`emulator` in the `$ANDROID_HOME` fallback; probe `%LOCALAPPDATA%\Android\Sdk` (Android Studio's Windows default). - simulator-server resolver + dispatcher + `bundle-tools` + `download-simulator-server.sh`: ship and resolve `simulator-server.exe` on `win32` (new `simulatorServerBinaryName()`), add `win32` to the bundled host keys, add the `simulator-server-argent-windows.exe` download target with PE arch validation. - `stop-metro`: resolve listening PIDs via `netstat -ano` on Windows (`lsof` is POSIX-only and threw ENOENT). - `adb.ts`: AVD root resolution used `$HOME` + `startsWith("/")` (rejects `C:\…`); now `os.homedir()` + `path.isAbsolute()`. - **`boot-device`**: the emulator was spawned `detached` with `stdio:"ignore"`; on Windows a detached emulator with NUL stdout/stderr never reaches `sys.boot_completed` (verified on `windows-latest`: the identical flag set boots fine with real handles, hangs with NUL). Redirect the detached emulator's output to a temp log file on win32. POSIX keeps `"ignore"`. **Tests** — cross-platform unit coverage for `commandOnPath` (both branches), win32 `.exe` Android resolution, win32 `.exe` simulator-server resolution, and a win32 AVD drive-path case; dep-gate tests now mock at the `commandOnPath` boundary so they're platform-agnostic. **CI** — `windows-e2e.yml` (`windows-chromium` on `windows-latest`): runs the resolver/dep unit tests natively on Windows, confirms `adb.exe` resolution via the SDK root, then drives a **real headless Chrome over CDP** through the tool-server (discover → screenshot → describe → tap → observe the DOM mutation). Flow in `scripts/ci/windows-chromium-e2e.mjs` (also runnable locally / in Docker). The `simulator-server.exe` build + the full **Android-emulator E2E on Windows** live in radon CI (the binary's source is the private radon repo). ## Verification (all green) - **Chromium control plane on real Windows** (`windows-latest`): `✓ discovered chromium-cdp-9222 → ✓ screenshot → ✓ describe → ✓ gesture-tap → ✓ DOM mutation observed`. Resolver/dep unit tests run natively; `adb.exe` resolves via the SDK root (it's *not* on PATH on the runner — the gap the resolver closes). - **Android emulator on real Windows** (radon#134, `windows-latest` / WHPX): the real Argent path — `boot-device` → `{ booted: true }` → screenshot via `simulator-server.exe` → gesture-tap — all green. (The boot-device fix above is what makes the detached emulator reach `boot_completed`.) - **Local clean-room E2E**: the Chromium flow runs green in a headless Linux Docker container (fresh `npm ci`, no host pollution). - **No regressions**: full tool-server suite (1624) + native-devtools-ios (16); ESLint/Prettier/typecheck clean; **Wayland E2E** (Linux AVD boot) and **Vega VVD E2E** still pass (they exercise the changed `adb.ts` / `boot-device.ts` / `vega-cli.ts` paths). ## Notes Android-emulator E2E needs WHPX nested virtualization — confirmed available on the current hosted `windows-latest` image (Server 2025); the emulator boots hardware-accelerated in ~3 min. --------- Co-authored-by: Ignacy Łątka <claude-hubert.gancarczyk@swmansion.com> Co-authored-by: Ignacy Łątka <latekvo@users.noreply.github.com>	2026-07-22 13:53:32 +02:00
filip131311	1f5b155229	chore: bump workspace packages to 0.16.1 (#539) ... ## What Lockstep-bump all 16 `packages/*` workspace packages (and the matching `package-lock.json` entries) from `0.16.0` → **0.16.1**. ## Verification - `node scripts/check-workspace-versions.mjs` → `All workspace packages are at 0.16.1.` - Lockfile diff is exactly 16 version-field swaps — no unrelated churn (the `"peer": true` regeneration noise from a newer npm was again kept out, same as #513). The one remaining `0.16.0` in the lockfile is the unrelated `@humanfs/types` dev dependency. - `packages/argent-private` submodule left pinned at `v0.16.0` — no `v0.16.1` tag exists there yet. 🤖 Generated with [Claude Code](https://claude.com/claude-code)	2026-07-22 11:03:13 +02:00
Juliusz Wajgelt	013d5b60c5	fix: get ax-service working on ios-remote (sim-remote --json spawn + TCP artifact diagnostics) (#536) ... ## Summary Three fixes that together get `describe` (and the other ax-service / native-devtools tools) working against **ios-remote** (`sim-remote`) devices — including from a **Linux** host. Reproduced end-to-end against a live remote iPhone 17 simulator over the QUIC relay. Before: `argent run describe --udid remote:<UDID>` returned an empty `ROOT AXGroup` with a misleading "reboot the simulator" hint. ### 1. `sim-remote spawn` output was never valid JSON (`fix(tool-server)`) `simctlSpawn` parses the CLI's stdout as one `{exit_code,stdout,stderr}` (or `{pid}`) JSON object, but `sim-remote spawn` only emits that when passed `--json`. Without it a **non-detached** spawn streams the child's raw output live, so `JSON.parse` throws `Unexpected end of JSON input`. This broke ios-remote describe at the first step: `remoteIosHost.bootstrapAx` runs `defaults write com.apple.Accessibility …` through a non-detached `simctlSpawn`, which failed before the ax-service daemon ever started — surfacing only as an empty AX tree. Fix: pass `--json` unconditionally (no-op for the already-JSON `--detach` path). ### 2. The tcp ax-service was resolved/packaged under a host-platform dir (`fix(native-devtools-ios)`) The tcp `ax-service` is a **darwin/iOS-simulator** binary that is uploaded to and `simctl spawn`d on the **remote** macOS orchestrator, so it's needed on any *host* platform. But it was resolved (and packaged) under `bin/<hostPlatform>/tcp` via `platformBinDir()`, so a **Linux host looked at `bin/linux/tcp` and never found the darwin-built binary** — the ios-remote path was effectively macOS-host-only. (The tcp dylibs were already neutral at `dylibs/tcp`.) Moved it to a platform-neutral `bin/tcp`, mirroring `dylibs/tcp`, and rewired every producer/consumer: - resolver: `platformTcpBinDir()` → `tcpBinDir()` = `BIN_DIR/tcp` - `native-devtools-ios/scripts/build.sh`: `bin/darwin/tcp` → `bin/tcp` - `scripts/download-native-binaries.sh`: `TCP_BIN_DIR` → `bin/tcp` - `packages/argent/scripts/bundle-tools.cjs`: copy from/to `bin/tcp` - tests assert the neutral location on both linux and darwin ### 3. Missing tcp artifacts were undiagnosable (`fix(native-devtools-ios)`) When a tcp artifact is absent (local/dev build, older package), the bare `... not found` error was thrown deep in the ax-service factory, where `describeIos` swallowed it and returned an empty tree plus `DEGRADED_HINT` — telling the agent to `boot-device --force`, a dead end. The only escape was discovering `ARGENT_SIMULATOR_SERVER_TCP_DIR` by reading source. Fix: `requireTcpArtifact` throws an actionable error naming the exact path, the override env var, and how to build it; `describeIos` surfaces that instead of the reboot hint. ## Testing - New `sim-remote-spawn-json.test.ts` — asserts `--json` on both plain and `--bin/--detach` argv, before the `--` separator. - `native-devtools-ios/test/index.test.ts` — the tcp binary resolves from the neutral `bin/tcp` on **both** linux and darwin; the not-found errors name their override env var. - `native-devtools-ios` (16) + ios/describe tool-server suites pass; typecheck, eslint, prettier clean. - Manual end-to-end against `remote:<UDID>` (darwin host): binary at `bin/tcp` → full tree from `source: "ax-service"`, no hint; binary removed → actionable `ARGENT_SIMULATOR_SERVER_TCP_DIR` hint.	2026-07-22 08:47:52 +02:00
Ignacy Łątka	300bc30e3d	fix(open-url): flag when a web URL may open the browser instead of an app (#476) ... ## Problem An agent calling `open-url` to deep-link into an app gets Safari instead: ``` open-url { "url": "https://bsky.app/profile/tvpworld.bsky.social" } → opens Safari ``` ### Root cause (not a wrapper bug — an iOS Simulator limitation) `open-url` on iOS is a thin wrapper over `xcrun simctl openurl`. An `https://` URL is a **Universal Link**, which only reaches a native app when that app is installed and verified for the link's domain. Two things bite here: 1. On the iOS **Simulator**, `simctl openurl` routes Universal Links to Safari even when the owning app *is* installed — a long-standing, documented limitation. Custom URL schemes (`scheme://…`) route reliably; Universal Links do not. 2. In the reported case the Bluesky app isn't installed at all, so Safari is the only valid handler — identical to tapping the link on a real iPhone with Bluesky absent. Reproduced on a booted iOS 18.5 sim: `simctl openurl <bsky https link>` launches `com.apple.mobilesafari`; the sim has zero third-party apps installed; `bluesky://…` fails with `-10814` (no registered handler), confirming absence. The real defect on our side: the result was **always** `{ opened: true }`, so a web URL that silently fell back to Safari was indistinguishable from a successful deep-link — the caller (an agent) believed it had reached the native app. There is no reliable way to observe which app actually handled the URL (Safari and other apps are invisible to the native-devtools socket), so the fix makes the ambiguity explicit rather than guessing. ## Fix - Add an optional `note` to the `open-url` result whenever a web URL (`http`/ `https`) is opened on a native device (iOS + iOS-remote). It states the URL may have opened in the browser and points to the reliable path: the app's **custom scheme** (`scheme://path`) or **`launch-app`** with the bundle id. - Update the tool description with the same deep-linking caveat. - Custom schemes, non-web schemes (`tel:`, `maps://`, `geo:`), and Chromium navigations are unaffected (no note). No URL rewriting — the URL is still handed to `simctl` unchanged. Scoped to iOS deliberately: Android App Links go through `am start` with a different verification/chooser path, and the reported symptom is iOS-specific. ## Verification - New unit tests (`open-url-deep-link-note.test.ts`, 4 cases): the helper returns the caveat for `http`/`https` (case-insensitive) and `undefined` for custom/non-web schemes; the iOS handler attaches `note` for the bsky https link (URL passed to `simctl` unchanged) and omits it for a custom scheme. - End-to-end against a live sim through the real `openUrlTool.execute`: - `https://bsky.app/profile/…` → `{ opened: true, url, note }` - `maps://?q=cupertino` (installed native handler) → `{ opened: true }`, no note - `bluesky://…` (not installed) → correct `FailureError` (existing behavior) - `tsc --noEmit`, `tsc --noEmit -p tsconfig.test.json`, and `prettier --check` all pass on the changed files.	2026-07-21 16:56:31 +02:00
filip131311	f0026ce6c8	fix(tool-server): stop native-devtools unix socket bind crashing the server (#531) ... ## Problem The per-UDID native-devtools unix listener binds with a bare `server.listen(socketPath)` and **no `error` listener** (`native-devtools.ts`, the `else` branch of the transport check). A bind failure — `EADDRINUSE` from a live/concurrent server on the same UDID, or `EEXIST` from a socket re-created in the window after the pre-unlink — fires an unhandled `'error'` event, which Node throws as an **uncaught exception that crashes the whole tool-server at startup**. The TCP branch right above it already guards its bind with `server.once("error", reject)`; `ax-service.startListener` does too. The unix branch was the one that didn't. ## Why it matters — 0.16.0 crash telemetry The crash-diagnostics shipped in 0.16.0 (`crash_fingerprint` / `crash_phase` / `error_syscall`) make this the clearly-dominant crash source. Scoped to `toolserver:stop`, `reason=crash`, `cli_version=0.16.0`: - **100% of crashes are socket/fs E-codes**, none are logic bugs. EADDRINUSE (95%), EEXIST (4%), ENOSPC/EPIPE tail. - Fingerprint **`dc063fe2`** — the native-devtools socket bind site — throws both **EADDRINUSE (65)** and **EEXIST (30)** at **`crash_phase=startup`**, across **~14 distinct users**. That's the widest-reach source by user count. (A separate single-user `toolserver_bind` restart loop accounts for most raw *volume*, but only one machine.) EEXIST at this site is the known concurrent-agent contention on `/tmp/argent-nd-<UDID>.sock` — a stale/racing socket file left by another server. ## Fix Extract the unix bind into `bindNativeDevtoolsUnixSocket(server, socketPath)`, mirroring `ax-service.startListener`: - Attaches an `error` listener so a bind failure **rejects** instead of throwing uncaught → routes into the factory's existing retry + failure-telemetry path, failing only this one service. - On `EADDRINUSE`/`EEXIST`, **unlink the stale entry and retry the bind once** — self-heals the unlink→listen race with a concurrent same-UDID server. - On any other failure (or a second failure), rejects with a coded `FailureError` (`NATIVE_DEVTOOLS_SOCKET_BIND_FAILED`, `failure_stage=native_devtools_socket_bind`) so it's cleanly classifiable in telemetry going forward. ## Testing - **Unit** (`native-devtools-socket-bind.test.ts`, 4 cases): free-path bind, stale-file self-heal, coded-FailureError on unbindable path, no-uncaught-throw when contending a live-held path. - **Full telemetry + registry suites**: 368 pass (new failure code accepted by the sanitizer allowlist). - **Live A/B against built output** — a live server holds the socket, then two child processes contend for it: - OLD (pre-fix `server.listen(path)`): **exit 1, uncaught EADDRINUSE crash** ← bug reproduced - NEW (compiled `bindNativeDevtoolsUnixSocket`): **exit 0, self-healed and bound** ← fix works - **Bundled-artifact check**: ran the esbuild `bundle-tools` step; the fix's retry logic and coded failure survive bundling intact in `dist/tool-server.cjs` (no dead-code-elimination surprise). 🤖 Generated with [Claude Code](https://claude.com/claude-code)	2026-07-21 10:28:14 +02:00
Jakub Piasecki	a0d1bbb1e7	feat(flow): indent nested steps in reports by block depth (#524) ... Flow reports rendered every step flat, hiding which steps ran inside a `when:` block or a `run:` fragment. The tool-server now stamps `StepReport.depth` (+1 per block directive, omitted at top level) and the CLI/MCP renderers indent step labels and under-step lines by it: ``` ✓ 1 launch ✓ 2 when visible "What's new" — condition met ✓ 3 tap "Skip" ✓ 4 run dismiss [dismiss] ✓ 5 tap "OK" [dismiss] ``` Invariants: - **Wire-compatible both ways** — a flow with no block directives reports byte-identical to the pre-depth shape; a pre-depth server renders flat as before. - **Skipped ≡ entered** — skipped/errored/aborted blocks report the same depths as entered ones, keeping reports comparable run-to-run. - **Untrusted wire data** — renderers clamp depth (display cap, not a producer bound): hostile values render flat or at the cap, never throw or allocate huge strings. Also fixes a pre-existing bug: under-step warning/artifact lines now stay aligned past 99 steps. Tests pin depth on every producer path (entered/skipped/errored/aborted blocks, `run:` success/failure markers, `run:`-in-`when:`) and renderer alignment incl. the clamp boundary. Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-21 07:28:48 +02:00
Ignacy Łątka	eb16d1c193	fix(tool-server): hard-kill (SIGKILL) timed-out iOS simctl calls so describe can't hang (#525) ... ## What happened An iOS `describe` call hung for **~24 minutes** on the benchmark host, logging the incoming request and then going completely silent until the tool-server was killed. The iOS `describe` path shells out to `xcrun simctl` for nearly every step — `isTvOsSimulator` (`simctl list`), the ax-service bootstrap (`simctl spawn defaults …`), and the native-devtools env setup (`simctl spawn launchctl …`). Every one is guarded by `execFileAsync(…, { timeout: 10_000 })`, so on paper each is bounded to 10s. The problem is in Node itself: **`execFile`'s `timeout` sends its `killSignal` (default `SIGTERM`) exactly once and never escalates to `SIGKILL`.** When CoreSimulatorService wedges (which rapid clone/boot/delete churn induces), the `simctl` child ignores SIGTERM, its stdio never closes, and the promise never settles — so the "10-second timeout" never actually fires. There is no outer deadline on the `describe` tool to catch it, so the call hangs until the process is killed. ## Why this is the root cause (not a guess) - **Static elimination:** every JS-level guard on the describe path (ax-service's 10s connect/query timers, native-devtools' 5s RPC timers) *would* have fired and let `describe` return — and it never returned. That leaves only an `execFileAsync` whose OS-level kill failed to settle the promise. - **Server logs:** the hung process logged the POST, then nothing for 24 min until the kill — the exact signature of a stuck subprocess await with no error thrown. - **Existing precedent:** `adb.ts` already fixes this identical class of bug for Android via `ADB_KILL_SIGNAL = "SIGKILL"` (see its comment: "Node's execFile default kill signal is SIGTERM, which an `adb` process blocked on a hung daemon can ignore — leaving the parent waiting past the deadline"). The same fix was simply never applied to the `simctl` path. - **Deterministic repro:** `execFileAsync('sh', ['-c', 'trap "" TERM; …'], { timeout: 2000 })` never settles; adding `killSignal: "SIGKILL"` makes it reject at ~2006ms. Reproduces both the hang and the fix. ## The fix - Add `SIMCTL_KILL_SIGNAL = "SIGKILL"` to `simctl-config.ts` and pass it alongside the timeout on every describe-path `simctl` invocation (`ax-prefs.ts`, `ios-devices.ts`, `ios-host.ts`), mirroring `ADB_KILL_SIGNAL`. - Add the missing `timeout` + kill signal to `listRunningUIKitApplicationBundleIds`, which had **no timeout at all** (a latent forever-hang on the `native-devtools-status` path). - Add `test/ios-simctl-hardening.test.ts` pinning every describe-path `xcrun simctl` call to `killSignal: SIGKILL` + a finite timeout. ## Verification - `tsc --noEmit` clean (src + tests). - Full tool-server suite: **2670/2670 pass**. - Confirmed the new test is a real guard: stripping the flag makes it fail, restoring makes it pass. ## Scope note This fixes the **proven** describe / native-devtools path. The same latent hang exists in other `simctl` call sites (`boot-device`, `launch-app`, `screenshot`, etc.) that use `execFileAsync` with the default signal — extending SIGKILL to the whole `simctl` surface is a reasonable follow-up but was kept out of this PR to stay scoped to the reported hang. One caveat: if `simctl` is ever stuck in true uninterruptible kernel state, even SIGKILL can't reap it until the syscall returns; the fully robust version would detach the await from the child via an independent deadline. SIGKILL matches the `adb` precedent and handles the realistic CoreSimulator-wedge case. --------- Co-authored-by: Ignacy Łątka <claude-hubert.gancarczyk@swmansion.com>	2026-07-20 19:26:33 +02:00
Piotr Krawiec	49e020bafd	fix(tool-server): resolve ps by absolute path so VVD dedup survives a sanitized PATH (#508) ... ## What A running Vega VVD registers a second adb transport (`emulator-<port>`), so it can surface in `list-devices` **twice** — once as `platform:"vega"` and once as `platform:"android"`. There's dedup logic (`resolveVvdShadowAdbSerials` + `filterVvdShadowsFromAndroid`) that drops the adb "shadow" row by matching the running VVD's console port — read from the process table via `ps` — against the adb serial's port. That dedup was spawning a **bare `"ps"`**, which relies on `PATH`. ## Why it broke An MCP server is frequently launched from a GUI / launchd context that inherits a **sanitized `PATH`** omitting `/bin`. There, `execFile("ps", …)` fails with `ENOENT`; the surrounding `catch` returns an empty port set, and the dedup silently no-ops — so the VVD shows up as two devices. It works fine from an interactive shell (where `/bin` is on `PATH`), which is why it doesn't reproduce in a terminal or in the existing tests. Observed: `list-devices` returned both a phantom `platform:"android"` `emulator-5554` and the real `platform:"vega"` device for a single running VVD. ## Fix Pin `ps` to its canonical absolute location, matching how the codebase already hardcodes `/bin/sh` (`android-binary.ts`, `vega-cli.ts`, `check-deps.ts`): ```ts export const PS_BIN = ["/bin/ps", "/usr/bin/ps"].find((p) => existsSync(p)) ?? "ps"; ``` Applied to all four `ps` spawn sites: - `vega-process.ts` — `listRunningVvdConsolePorts`, `listRunningVvdPids` - `vega-cli.ts` — `collectDescendantPids`, `pgidMembers` (same latent PATH fragility in the process-reaping paths) The bare-`"ps"` fallback is retained only if neither canonical path exists, preserving `PATH` resolution for an atypical layout. ## Tests - New regression test in `vega-process.test.ts` that strips `/bin` and `/usr/bin` from `PATH` and asserts the probe still spawns `ps` (a bare `"ps"` ENOENTs there — verified the test fails against the pre-fix code). - Updated the `list-devices.test.ts` mock to match `ps` by basename, since production now passes an absolute path. - `npm run build`, typecheck, lint (`--max-warnings 0`), and the full vega/list-devices suite (47 tests) all pass. ## Verification End-to-end `list-devices.execute()` under a launchd-style minimal `PATH` now returns exactly **one** device (the Vega), with no android shadow. `PS_BIN` resolves to `/bin/ps` and reads the VVD's console port even with `/bin` removed from `PATH`. --------- Co-authored-by: Piotr Krawiec <krawipio@amazon.pl>	2026-07-20 17:05:16 +02:00
filip131311	66e051fe8b	fix(debugger): collapse a device's two ids onto one debugger instance (#528) ... ## The problem A device is reached through **two id namespaces** that name the same thing but are different strings: - the **stable id** the caller connects with — an iOS UDID / Android serial / Vega serial from `list-devices`; - the **`logicalDeviceId`** Metro's inspector-proxy echoes back for that connection (an opaque per-connection handle). `logicalDeviceId` is not derived by Argent — it is echoed verbatim from Metro (`js-runtime-debugger.ts`), and Metro never sees the UDID, so there is **nothing to join on synchronously**. The debugger service is cached by its URN, which embeds `device_id` verbatim: ``` JsRuntimeDebugger:<port>:<device_id> ``` `debugger-connect` took the UDID, returned the logicalDeviceId, and its description told callers to *"forward it as device_id to all subsequent debugger-\* calls."* Following that instruction produced a **different URN** → a **second `JsRuntimeDebugger` instance** → a second `CDPClient`, a second console-log server, and a split log file — **all for one device**. The second attach also kicks the first off Metro's single-debugger-per-target proxy. Nothing deduplicated them. It only *looked* fine because with a single device on a Metro port, `selectTarget`'s single-device fallback quietly connects anyway; the split surfaces as "the debugger randomly drops" and logs landing in the wrong bucket. Secondary damage the same split caused: - `classifyDevice()` is shape-based and was fed the logicalDeviceId → an iOS device's forwarded id classified as **Android** in the capability gate + telemetry. - The docs asserted *"iOS simulator UDID, Android logicalDeviceId"* as if a UDID were the iOS logicalDeviceId — the repo's own test says the opposite. - `debugger-component-tree` printed the logicalDeviceId under a `udid:` label — teaching callers the wrong name. ## The fix — synchronous, within the existing `services()` design - **Learn an alias** `logicalDeviceId → connect-id` as a side effect of a successful connect (the one place both ids are known at once; see `utils/debugger/device-alias.ts`), and **canonicalize `device_id` through it at every URN-building site**. A forwarded logicalDeviceId now resolves to the already-open instance; unknown ids (the connect id itself, Chromium ids) pass through unchanged, so it is safe to call everywhere. **No Metro round-trip on the hot path — `services()` stays synchronous.** The alias is 1:1 (a logicalDeviceId is unique per connection) and is cleared on dispose. - **Rewrite the `device_id` docs** across `debugger-*`, `network-*`, and `react-profiler-*`: pass the **same list-devices id you connected with**; the returned logicalDeviceId is informational (forwarding it still resolves, via the alias). Removes the instruction that caused the double instance and the false "UDID = logicalDeviceId" wording. - **Fix the `debugger-component-tree` header** (`udid:` → `logicalDeviceId:`). Covered call sites (all that embed `device_id` into a Metro URN): `debuggerServiceRef` (connect/evaluate/status/log-registry), `debugger-reload-metro`, `debugger-component-tree`, `debugger-inspect-element`, `react-profiler-start` (+ its session URN), `react-profiler-stop`, `network-logs`, `network-request`. ## Verification **Live**, against a real iOS sim + Metro (my-app, RN 0.81.5), driving the branch tool-server directly: | step | result | URNs instantiated | |---|---|---| | `debugger-connect { device_id: <UDID> }` | returns `logicalDeviceId: d52ad36b…` | `JsRuntimeDebugger:8081:<UDID>` | | `debugger-evaluate { device_id: d52ad36b… }` (forward the logicalDeviceId) | `42` ✅ | **no new URN — reused** | | counterfactual: `debugger-evaluate { device_id: some-unaliased-id }` | `42` ✅ | **`JsRuntimeDebugger:8081:some-unaliased-id` — a distinct 2nd instance** (the pre-fix behavior, reproduced) | | `debugger-component-tree { device_id: <UDID> }` | header reads `logicalDeviceId: d52ad36b…` ✅ | reused | **Unit** — new `test/metro/device-alias.test.ts` covers the alias (learn / canonicalize / self-alias no-op / missing-id / forget) and that `debuggerServiceRef` yields the same URN whether called with the UDID or the forwarded logicalDeviceId. Full tool-server suite green (2726 tests). ## Not in scope Renaming the `device_id` param to `udid` (or vice-versa) — that is a breaking MCP wire change. This PR is additive: a forwarded logicalDeviceId keeps working, it just no longer opens a second connection. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-20 16:21:56 +02:00
Ignacy Łątka	78d3184ba8	fix(scripts): stop extract-tools dropping tools with long descriptions (#436) ... ## Defect `scripts/extract-tools.mjs` extracts MCP tool definitions by regex to feed the downstream `spidershield scan --tools-json` security scan. For each `id:` match it scanned only the next 2000 chars (`const descWindow = afterId.slice(0, 2000)`) for the `description:` value, and the description regexes require the string's closing delimiter to fall inside that window. Any tool whose description's closing delimiter sits past ~2000 chars is therefore matched as `null` and **silently dropped** - never emitted, never security-scanned. Two shipping tools hit this: - `run-sequence` (`packages/tool-server/src/tools/run-sequence/index.ts`) - a ~4285-char multi-line template-literal description whose closing backtick sits ~4324 chars past its `id:`. - `describe` (`packages/tool-server/src/tools/describe/index.ts`) - a ~2195-char description whose closing backtick sits ~2252 chars past its `id:`. **Security impact:** `describe` is the accessibility / DOM tree tool, exactly the kind of tool a `spidershield` scan should cover, and it was being silently excluded alongside `run-sequence`. A dropped tool is not a scan finding, so the gap was invisible. ### Repro (before) ``` $ node scripts/extract-tools.mjs | grep -c '"run-sequence"' 0 $ node scripts/extract-tools.mjs | grep -c '"describe"' 0 $ node scripts/extract-tools.mjs | grep -c '"gesture-tap"' 1 # total tools emitted: 70 (run-sequence AND describe both missing) ``` ### After ``` $ node scripts/extract-tools.mjs | grep -c '"run-sequence"' 1 $ node scripts/extract-tools.mjs | grep -c '"describe"' 1 # total tools emitted: 72 (both captured, run-sequence's full 4285-char description intact) ``` ## Fix - Drop the fixed 2000-char lookahead. Each tool's `description:` is resolved at the **same object-literal brace level** as its `id:` by a forward scan that tracks brace depth over real code only: comments, string literals, template literals (with `${...}` interpolations skipped opaquely, recursively), and regex literals (prev-token heuristic incl. regex-permitting keywords like `return`) are skipped whole, so nothing inside them can open a fake string, shift the depth, or match as a `description:`/`id:` token. The value is then parsed to its actual closing delimiter, so a description of any length is captured in full. - Because matching is by brace scope rather than raw position, a stray `id:`/`description:` token can't corrupt extraction: a description-less tool can't borrow the next tool's description, an `id:` appearing inside description text or a comment can't truncate or overwrite anything, and an `id:` key nested inside a value object (e.g. `defaultPayload: { id: "example" }`) is neither emitted as a spurious tool nor allowed to drop the real one. - Captured text follows full JS cooked-string semantics: named escapes, `\xNN`, `\uNNNN`, `\u{...}`, identity escapes, line continuations, and template `\r\n`/`\r` -> `\n` normalization - the emitted (and security-scanned) text is the string the runtime renders. - A description value that is not a single plain literal - a concatenation, a `${...}` interpolation, a method/operator suffix (`"...".slice(0, 3)`), `as const` - is never emitted as a truncated/wrong literal: it warn-skips on **stderr** (stdout stays valid JSON for the scanner). Non-interpolated template-literal ids (`` id: `x` ``) are extracted; interpolated ids stay out of scope like const-reference ids. - Duplicate ids keep the first occurrence and warn (exported as a pure, unit-tested function). - The extractor stays dependency-free (node: builtins only): the tool-description-quality workflow runs it on a bare checkout without `npm ci`. - Output JSON shape is unchanged. ## CI guard Adds `scripts/extract-tools.test.mjs` (node's built-in test runner, wired into `npm run test:scripts`; 36 tests). Ground truth: the real-tree tests parse every tool source file with the actual **TypeScript parser** (a root devDependency, test-only) and require the extractor's output to equal the AST **exactly - names and descriptions byte-for-byte**. Any drop, corruption, or fabrication on a shape that enters the tree fails CI loudly, with no reliance on stderr warning formats and no false red from `id:`-like text in comments or strings. Two policy gates keep un-extractable shapes out of the tree instead of letting them silently leave the scan: a `description` that cannot be read statically (non-literal value, shorthand/getter/method/computed member, or a spread sibling that may carry/override it) and a plain-literal description written **before** its `id:` (the scan is forward-only) each fail with an actionable, file-naming message. Fixture tests pin the parsing rules independent of any real tool's wording - long descriptions (>4000-char value, >2000 chars of siblings between `id:` and `description:`), embedded `id:`/`description:` tokens, comments, keyword-position and sibling regex literals, division, nested templates and interpolation content, template/`as const` ids, the full escape suite, CRLF cooking, single-quoted forms, trim, warn-skip classes, and the duplicate-id warning. Each new fixture was verified to fail under a targeted mutation of the extractor. Note: tools registered with a const-reference / dynamic id (e.g. `id: AWAIT_UI_ELEMENT_TOOL_ID`) rather than a static literal stay out of scope for this extractor - a separate, pre-existing limitation unrelated to the description window, and one this static/lexical extractor cannot close soundly (it has no tool-scope knowledge, so a blanket warning on every `id: <identifier>` would also fire on legitimate nested non-tool keys like `{ id: someVar }` in a payload/example object). The full set currently taken out of the scan this way is `app-map-crawl`, `app-map-export`, `app-map-navigate`, `app-map-query`, `await-screen-idle`, and `await-ui-element`. A proper fix is a follow-up covering const-ref id resolution plus a real-tree emit-count and empty-stderr assertion so this silent-omission class trips CI if it ever regresses. ## Verification - `node scripts/extract-tools.mjs` -> 72 tools, `run-sequence` and `describe` both present (total 70 -> 72), byte-identical to the TypeScript-AST parse of the tree, no stderr warnings - `npm run test:scripts` -> all pass (`extract-tools.test.mjs`: 36 tests) - mutation checks: window-bounding, depth-anchor removal, trim removal, dedup neutralization, single-quote-branch neutralization each fail the suite - `npm run typecheck:scripts` -> clean - `prettier` + `eslint` on changed files -> 0 problems - lockfile: `npm install --package-lock-only --ignore-scripts` -> no diff (idempotent)	2026-07-20 12:56:44 +02:00
Jakub Piasecki	3f602a7a9b	feat(flow): conditional when blocks (#498) ... ## What A `when:` block runs a step list only when one condition holds — a UI condition (`exists`/`visible`/`hidden`/`text`, the await/assert shapes) or a static `platform` test. **No else**, by design: a block exists to restore determinism (dismiss an interstitial, reconverge), never to test two paths. Tap-if-present is a one-step block: `when: { visible: "Got it" }` + `steps: [tap: "Got it"]`. No per-step `optional:` — `when:` covers every directive once. The key is rejected at parse with a pointer to `when:`, not silently dropped (a Maestro habit that would leave a "can't fail" step hard-stopping the flow). ## How - The guard reuses the assert engine at the 1s grace (`timeout` is a parse error), so a skipped block barely costs a clean run. - Verdicts are evidence-based: no trustworthy read in the window → indeterminate → the step **errors** ("could not evaluate" is not "condition false"); a transient read failure after trusted reads showed the condition false stays a clean skip. - `platform` folds `ios-remote` into `ios` — the parser rejects that spelling, so the fold is the only way a guard matches a remote sim. - A skipped block reports one line per authored step, same shape for unmet guard, hard stop, or cancellation; everything goes through `pushReport`, so when lines stream live. Failures inside an entered block hard-stop as usual. - Results carry an explicit `aborted` flag; `ok` keys off fail/error/cancel, not skip lines. - Nesting is capped at 20, so a cyclic YAML alias is a structured parse error, not a stack overflow. ## Testing `vitest` 2546 pass (17 when-specific); `tsc --noEmit` (tool-server, argent-mcp, argent-cli), eslint, prettier clean. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-20 10:26:34 +02:00
Jakub Piasecki	8d633700d7	feat(flow): coordinate targets for tap and long-press (#504) ... ## Summary This adds raw normalized screen coordinates as first-class targets for both `tap` and `long-press`. Gestures can now target either an element selector or a point, while keeping the existing selector auto-wait and off-screen diagnostics. Supported forms include: ```yaml - tap: { x: 0.5, y: 0.6 } - tap: { on: { x: 0.5, y: 0.6 }, times: 2 } - long-press: { x: 0.5, y: 0.6 } - long-press: { on: { x: 0.5, y: 0.6 }, duration: 1200 } ``` ## What changed - Introduced a shared gesture-target parser for selector and point targets. - Added raw-point execution for `long-press` and shared point resolution between tap and long-press. - Validate coordinates as finite normalized `0–1` screen fractions, rejecting pixels, malformed points, mixed selector/coordinate maps, and unknown point keys. - Canonicalize option-bearing coordinate gestures under `on`, keeping option keys separate from target fields. - Preserve coordinate targets in recording summaries and flow progress reports instead of displaying an undefined selector. - Added serialization validation so recording cannot persist a flow that would fail when parsed for replay. - Updated the flow authoring skill and tool description with the new coordinate forms. ## Behavior notes - Raw points act immediately and do not resolve or observe the UI tree. - Selector targets retain settling, auto-wait, and the existing `scroll-to` hint when an element cannot be found. - Observation directives such as `type`, `await`, `assert`, and `scroll-to` remain selector-only. - The mixed spelling `tap: { x, y, times }` is now intentionally rejected; use `tap: { on: { x, y }, times }` instead. ## Validation - Full tool-server suite: 2,618 tests passed across 266 files. - Added parser, serialization, recording, touch execution, Chromium execution, reporting, and malformed-input coverage. - Tool-server build, test typecheck, ESLint, Prettier, and skill validation passed.	2026-07-17 14:48:29 +02:00
Jakub Piasecki	1a4f89cd5f	feat(flow): allow to compose all flows via run: (#507) ... ## Summary `run:` accepted **fragments only** — an e2e flow (one starting with `launch:`) was rejected as a `run:` target. This lifts that: an e2e flow can now be nested via `run:`, its `launch` running inline (a real terminate + relaunch on native). Composition becomes uniform — any flow can be a reusable building block. ## What changed - **`flow-run.ts`**: dropped the `isE2eFlow` rejection in `execRunStep`; cycle / `MAX_RUN_DEPTH` guards still bound recursion. - **`flow-add-step.ts`**: the recorder now captures a recorded `flow-execute` of an e2e sibling as a portable `run: <name>` directive (was: raw `tool:` step). - **`flow-utils.ts`, `argent-create-flow/SKILL.md`**: updated docs/skill that said e2e flows can't be `run:` targets. ## Known limitation — Chromium Chromium `launch` boots an Electron app from a *path*, wired to the top-level flow only — so a nested **chromium** e2e flow doesn't boot its own app. Native nesting is correct; chromium nested e2e is unsupported. ## Testing Rewrote the two affected tests (composition + recorder). Full flows suite green (349 tests); `tsc --noEmit` clean.	2026-07-17 14:18:32 +02:00
Jakub Piasecki	49991e9fe1	feat(screenshot-diff): support full-image comparisons (#515) ... ## Summary - Add an explicit top-mask policy to the shared PNG differ. - Preserve status-bar masking by default while allowing isolated image regions to compare every row. - Add real-PNG regressions for top-band changes and one-row images. This prepares the differ for cropped comparisons without changing existing callers. ## Testing - Screenshot-diff tests - Tool-server build	2026-07-16 17:21:59 +02:00
filip131311	b50d51a2de	chore: bump workspace packages to 0.16.0 (#513) ... ## What Lockstep-bump all 16 `packages/*` workspace packages (and the matching `package-lock.json` entries) from `0.15.0` → **0.16.0**. ## Why The `packages/argent-private` submodule is already pinned at **v0.16.0**, while the workspace packages sat at 0.15.0. This aligns the whole repo on the single 0.16.0 version. ## Verification - `node scripts/check-workspace-versions.mjs` → `All workspace packages are at 0.16.0.` - `git submodule status` → clean (no `+`), pinned at `v0.16.0`. - Lockfile diff is exactly 17 version-field swaps (no unrelated churn — a full `npm install --package-lock-only` regeneration was rejected because it introduced unrelated `"peer": true` churn from a newer npm).	2026-07-15 20:53:36 +02:00
filip131311	92b8c039c3	fix(flow): refuse invisible-only text selectors — record coordinates instead (#511) ... ## The bug (found in the 0.15.0 full-surface QA, on both the Android emulator and a physical S24) Recording a `gesture-tap` on an icon-font tab-bar item wrote a flow step that displays as an **empty selector**, with the coordinates gone: ```yaml steps: - tap: text: # ← actually U+E163, an icon-font Private Use Area glyph ``` and `flow-execute` then **silently passed** against target `""`, tapping an element no reader of the flow can predict. Root cause (hexdump of the QA-recorded file: `ee 85 a3` = U+E163): icon fonts expose their glyph as the element's accessibility label; `deriveSelector` accepted any label that survived `trim()`, so a PUA code point counted as "stable text". This violated the rewrite's own documented contract — *"otherwise coordinates are kept with a warning"* — whose fallback path existed and worked, but never ran for this case. ## The fix — one predicate, three layers `hasVisibleText()` (strip Unicode `Cf` format / `Co` private-use / `Cc` control, then trim; require something left): 1. **`deriveSelector`** — invisible-only label/value is not stable text; fall through to role, then to the recorder's existing kept-coordinates path. 2. **`selectorToYaml`** — the empty-text guard previously covered only the bare-string spelling; it now also rejects empty/invisible text on the strict `{text: …}` map form, so a hand-built selector fails loudly instead of writing an unreadable flow file. 3. **`selectorSchema`** — parse-side refinement, so flow files already recorded broken on 0.15.0 fail with an actionable message ("text must contain at least one visible character … select by identifier or role instead") instead of false-passing at replay. This also hardens the `await-ui-element` tool surface, which shares the schema. Text that merely *contains* an icon glyph alongside real text ("⟨U+E163⟩ Explore") stays valid throughout. ## Verification - Unit: `deriveSelector` PUA/ZWSP/mixed cases, serialize + parse rejection round-trips (explicit `\uXXXX` escapes, no invisible bytes in the test source). - Full tool-server suite: **2667 passed**. - **Live on the Pixel_9 emulator against the original QA repro** (my-app tab bar, same coordinates): recording now produces `tap: {x: 0.75, y: 0.947}` with the documented *"kept coordinates (brittle)"* warning — the role fallback was correctly caught by the existing resolves-to-a-different-element guard — replay passes 2/2 on the coordinate targets, and executing the old broken YAML now fails parse with the visible-character error. 🤖 Generated with [Claude Code](https://claude.com/claude-code)	2026-07-15 20:31:23 +02:00
Ignacy Łątka	af8476c0a9	feat(vega): support the JS-runtime debugger and network inspector on Fire TV (#502) ... Vega's React Native is a fork of **RN 0.72**, so it serves the *legacy* Hermes inspector rather than the post-0.73 (Fusebox) debugger. The `debugger-*` / `view-network-*` / `react-profiler-*` tools were never gated for it, so every call against a VVD was rejected before any RN code ran: ``` Tool 'view-network-logs' is not supported on vega vvd (no vega support declared). ``` That gate turned out to be the only thing in the way for most of them. The concern that prompted this was that the network inspector needs the new debugger. It does not: argent's network inspector never touches the CDP `Network` domain, it monkey-patches `fetch` over `Runtime.evaluate` and reads back a global array. `Runtime.evaluate` has worked in Hermes since long before 0.73, so the network inspector is precisely the tool that is *unaffected* by the missing new-debugger stack. ## What now works on Vega Gated in via `DEBUGGER_TOOL_CAPABILITY` (these need only `Runtime.evaluate`): `debugger-connect` · `debugger-status` · `debugger-evaluate` · `debugger-log-registry` · `view-network-logs` · `view-network-request-details` ## What stays gated off, and why `debugger-component-tree` · `debugger-inspect-element` · `debugger-reload-metro` · `react-profiler-*` · `profiler-*` Two different reasons, and it is worth keeping them apart: - **`debugger-component-tree` and `debugger-inspect-element` are hard-blocked.** They are the only two callers of `cdp.evaluateWithBinding`, i.e. they deliver their payload over `Runtime.addBinding` / `Runtime.bindingCalled`. RN 0.72's Hermes **ACKs `Runtime.addBinding` and never installs the binding** — confirmed on the VVD: after a successful `debugger-connect`, `typeof __argent_callback` is still `"undefined"`, and no `bindingCalled` ever fires. They would hang until timeout. - **`debugger-reload-metro` and the profiler tools are simply unverified here.** They do *not* use the binding (`reload-metro` is `Page.reload` plus an HTTP `/reload` fallback; the profilers ride `Runtime.evaluate` and the CDP `Profiler` domain). They share `RN_ONLY_TOOL_CAPABILITY` and stay out of scope rather than ship untested. Either way the capability gate turns a hang (or an unknown) into an immediate, explicit "not supported". `describe` remains the way to read on-screen structure on Vega. Worth noting for a follow-up: the component-tree data itself *is* reachable on RN 0.72 — walking the DevTools hook via a plain `Runtime.evaluate` returns the real fiber tree (640 fibers on the sample app). Component-tree is blocked by argent's transport choice, not by a missing runtime capability, so a non-binding fallback would unlock it. ## Two bugs this surfaced **A Vega `device_id` could bind to another device's runtime.** Vega's legacy inspector-proxy emits no `reactNative` block at all, so its targets carry no `logicalDeviceId`. `selectTarget` both matched `device_id` on `logicalDeviceId` *and* counted connected devices the same way — so a Vega device was invisible to the multi-device guard from #397: its id matched no target, the guard counted zero devices, concluded there was nothing to disambiguate, and fell through to the priority target. With a Fusebox iOS/Android app on the same Metro, that target wins the priority list, so `debugger-evaluate` would have run JS **in the wrong app** while `debugger-status` reported the other device's name and `isNewDebugger: true`. Devices are now keyed by `logicalDeviceId || deviceName` (the legacy proxy always reports a name), so the guard sees them and refuses to guess. A lone VVD still falls back to its own targets. This is not Vega-specific: any RN ≤ 0.72 device was invisible the same way. **Metro's missing project-root header.** RN 0.72's Metro never sends `X-React-Native-Project-Root`, and `discoverMetro` treated a missing header as fatal — which took down evaluate, console logs and the network inspector too. The header only feeds source-map / `file:line` resolution, which degrades cleanly to no-location, so it is now optional. Platform-agnostic, not a Vega special-case: a missing source-map hint should never kill an otherwise working debugger session. That made `projectRoot: ""` a reachable state, which two source-resolution paths mishandled. `symbolicate` stripped the root with `file.replace(projectRoot + "/", "")`, which on an empty root degrades to `.replace("/", "")` and deletes the first slash *anywhere* in the path (`src/screens/Home.tsx` → `srcscreens/Home.tsx`). And `readSourceFragment` did fail closed, but only because `fs/promises.realpath("")` happens to reject where the sync API returns the tool-server's cwd — it now bails explicitly instead of leaning on that quirk. Both are reachable from `debugger-inspect-element` on any legacy Metro (not on Vega, where it is gated off). ## Verification Driven end-to-end against a real VVD (`amazon-6b8a…`) running the `react-native-multi-tv-app-sample` Vega app (Debug `.vpkg`, Metro reachable via reverse port-forward), through a tool-server built from this branch: ``` debugger-status -> connected: true, deviceName: kepler-device, isNewDebugger: false, projectRoot: "" debugger-evaluate -> "hermes=object fetch=function global=object" debugger-log-registry -> captured console.log "PR502_E2E_MARKER" === NETWORK LOGS (page 1/1, 2 total) === {id: rn-net-1} "GET /todos/7" 200 Fetch 98 B 55 ms {id: rn-net-2} "GET /users/3" 200 Fetch 520 B 17 ms view-network-request-details -> full request/response headers, status, timing ``` And the gated tools fail fast (0.02s) rather than hanging: ``` debugger-component-tree -> not supported on vega vvd debugger-inspect-element -> not supported on vega vvd debugger-reload-metro -> not supported on vega vvd react-profiler-start -> not supported on vega vvd ``` Re-ran the whole sequence against the fixed target-selection to confirm the single-VVD path still connects. Also run locally: `tsc --build`, `tsc --noEmit -p tsconfig.test.json`, `eslint . --max-warnings 0`, `prettier --check`, `grade-skills`, and the tool-server unit tests (199 files / 1740 tests). Tests added: `vega-target-routing` (the mis-route, using a target payload captured verbatim from the live VVD), `source-resolver-empty-root` (both empty-root paths), and `vega-debugger-capability` — which now drives the real `ToolDefinition.capability` fields and `resolveDevice` instead of a hand-written name↔constant pairing, pinning all 6 enabled and all 14 gated tools. The old version passed even with `debugger-status` wired to the wrong capability constant. Scope note: VVD only — no tool declares `vega: { device: true }`, so physical Fire TV hardware is untouched.	2026-07-15 15:36:12 +02:00
filip131311	70660378bb	feat(tool-server): type secrets via {{secret:NAME}} placeholders — plaintext never enters agent context (#506) ... ## Why Feedback: unlike Stagehand's `act("type %pw% into password", { variables: { pw } })`, argent had no way to type a credential without the LLM seeing the plaintext — which disqualifies it as a CI agent. In the MCP model the agent composes the `keyboard` call itself, so a plaintext password lands in **six** places: the agent transcript, `~/.argent/mcp-calls.log` (spyLog records full args + result), the flag-gated tool-server event log, the `typed` result echo, recorded flow YAMLs (committed to the repo), and the post-type auto-screenshot (plaintext back into context as pixels for non-secure fields). ## What `keyboard` and `paste` now accept **`{{secret:NAME}}`** placeholders in `text`, resolved server-side from **`ARGENT_SECRET_NAME`** environment variables: ```yaml # GitHub Actions env: ARGENT_SECRET_APP_PASSWORD: ${{ secrets.APP_PASSWORD }} ``` ```json { "udid": "<UDID>", "text": "{{secret:APP_PASSWORD}}", "key": "enter" } ``` **Resolution happens inside the tool's `execute`** — after every existing logging boundary — so spyLog, the event log, the transcript, and recorded flows all see only the placeholder, with near-zero extra redaction work: - `run-sequence` keyboard steps and flow `type` steps go through `invokeSubTool` into the same `execute` → covered for free. A recorded login flow stores the placeholder verbatim, so the committed YAML is secret-free — and agent-less `argent flow run` (#429) resolves it in CI from the job's env, no LLM in the loop at all. - The mandatory `ARGENT_SECRET_` prefix is an allowlist by construction: a prompt-injected agent can never exfiltrate `AWS_SECRET_ACCESS_KEY` or `GITHUB_TOKEN` through this mechanism — only vars the user deliberately exposed under the prefix resolve. - `typed` echoes the placeholder, never the value. - Backend errors are scrubbed at the resolution site (e.g. a failed Android `input text` echoes the device-side command line containing the secret) — message and stack, in place, preserving the error class and with it the HTTP-status/telemetry mapping. - Unknown placeholder → 400 listing the **names** of available secrets, never values (`SECRET_PLACEHOLDER_UNKNOWN`). - **Auto-screenshot skip:** the MCP layer deep-scans args for `{{secret:` and replaces the after-action screenshot with a text note — otherwise a non-secure-entry field hands the plaintext straight back to the model as an image. Covers nested `run-sequence` steps too. - Remote-routed setups resolve on the machine that types (the tool-server's env) — documented in the skill. - Inert unless a placeholder is used; no feature flag. ## Docs - `keyboard` / `paste` tool descriptions - `argent-device-interact` skill: "Typing secrets" section (incl. *don't* `describe`/`screenshot` the field you just filled — submit first) - `argent-create-flow` skill: never record a real credential; placeholder flows stay secret-free in the repo ## Known residual risks (shared with Stagehand-style designs) - A prompt-injected agent could direct `{{secret:X}}` into an attacker-visible field and screenshot it — inherent to any "agent types secrets" design; the prefix allowlist and no-read-back keep the blast radius to secrets deliberately exposed. - `describe` can read back a non-secure field's value after typing; iOS secure fields briefly show the last typed character; Android typing puts the resolved string on the device-side `input` command line. Acceptable for emulator CI; noted in the skill. - `keys` in the result still reflects the real keystroke count (secret length) — kept for debuggability. ## Tests - `keyboard-secrets.test.ts`: resolution (embedded/repeated placeholders, malformed shapes ignored), unknown-name error lists names but never values, redaction preserves error class, full `execute` round-trips on the chromium branch asserting the plaintext appears nowhere in results or thrown errors, paste via mocked `sendCommand`. - `auto-screenshot.test.ts`: `containsSecretPlaceholder` on flat/nested/unserializable args (fails safe). - Full suites green: tool-server 2550, argent-mcp 76, registry 87; builds + `typecheck:tests` + eslint + prettier clean. 🤖 Generated with [Claude Code](https://claude.com/claude-code)	2026-07-15 13:42:55 +02:00
Jakub Piasecki	3d3b82a076	feat(flow): regex matching via matches in assertions and selectors (#503) ... ## What - Add `matches` as a case-sensitive JavaScript regex comparator for `await` and `assert` text conditions. - Support `{ text: { matches: ... } }` in every flow selector slot, combined with `id` and `role`. - Preserve regex matchers through parsing, YAML serialization, recording summaries, and run reports. ## Correctness - Prevent empty-matchable patterns from matching unlabeled nodes or empty assertion text. - Reject unknown raw `await-ui-element` selector keys instead of silently dropping constraints. - Reject selector combinations YAML cannot round-trip without changing their semantics. - Document native label aggregation accurately and keep action ranking consistent. ## Maintenance - Share selector-field and regex-syntax validation across both matcher parse paths. - Compile selector regexes once per tree walk and full-match regexes once per ranking pass. - Make comparator serialization exhaustive, extract the duplicated flow test harness, and scope slow-test timeouts narrowly. ## Verification - Full tool-server suite: 2,588 tests across 263 files. - Source and test typechecks, ESLint, Prettier, and skill-copy validation pass.	2026-07-15 08:07:03 +02:00
Jakub Piasecki	5082b63082	feat(flow): multi-tap via tap times and gesture-tap clickCount (#497) ... Flows can now express double-taps declaratively: ```yaml - tap: { on: Login, times: 2 } # selector double-tap - tap: { x: 0.5, y: 0.57, times: 2 } # coordinate double-tap ``` The selector nests under `on` so option keys never share a map with selector fields — zod would silently strip them; mixing errors with a hint instead. `times: 1` normalizes to absent and the serializer emits the minimal spelling, keeping parse/serialize exact inverses. The taps dispatch as **one gesture** via `gesture-tap`'s new `clickCount` (1–10): N Down/Up pairs ~100 ms apart on touch, escalating CDP `clickCount` per click on Chromium (what makes `dblclick` actually fire) — never N separate calls whose RPC gaps could miss the OS double-tap window. The recorder carries a recorded `clickCount` into `times`, so a recorded double-tap can't silently replay as a single tap.	2026-07-15 07:55:31 +02:00
Jakub Piasecki	7bf693a573	feat(flow): long-press directive (#500) ... Press-and-hold on an element — context menus, reorder activation — with the same resolution behavior as `tap` (settled tree, auto-wait, no auto-scroll) and the same options shape: a bare/strict selector, or `long-press: { on: <selector>, duration: <ms> }` with the selector nested under `on` so option keys never mix with selector fields. The default 800ms clears both platforms' recognizers (iOS 500ms, Android ~400ms). Touch platforms dispatch one `gesture-custom` train (`Down`, then `Up` delayed by the duration) so the hold length is exact; Chromium maps to a mouse press-hold-release (`gesture-drag`, from == to) — a desktop context menu is a right-click and is deliberately not aliased. Vega rejects upfront with the other touch directives. No coordinate form: a point long-press stays the `gesture-custom` escape hatch.	2026-07-14 18:18:24 +02:00
Jakub Piasecki	e45f148c50	fix(tool-server): press named key after text in keyboard tool (#486) ... ## Problem A `keyboard` call combining `text` and `key` pressed the named key **before** typing the text — the reverse of the intended "type, then submit". Every platform branch had the same ordering (copied verbatim from the original iOS implementation into each port), and nothing in the schema or description documented it. Ironically, run-sequence's own description lists *"typing then pressing enter"* as a canonical use case. The observed failure: an agent ran `{ text: "jane@test.dev", key: "enter" }` against a freshly-focused email field in a React Native dev build. Enter fired first into the still-empty field, submitting and blurring it; the text was then typed with nothing focused. RN's `RCTKeyCommands` matches Cmd-registered dev commands even with no modifier held when there is no first responder (`_flags == flags || flags == 0` in `matchesInput🎏`), so the bare `d` in ".dev" toggled the dev menu mid-sequence, and every subsequent tap landed on the dev-menu overlay. ## Fix - All executing branches now type `text` first and press `key` after it: - `simulator-server-keys.ts` (iOS simulator / Android emulator) - `keyboard/platforms/chromium.ts` (Electron / CDP) - `keyboard/platforms/vega.ts` (Fire TV) - (the TV branch already rejects `key`; unchanged) - Unknown key names are still rejected **before** any text is typed — each branch resolves the named key up front instead of relying on the old key-first order for fail-fast. The Vega branch gained `resolveVegaNamedKeycode` in `vega-input.ts` so validation is separable from injection. - The ordering is now documented in the keyboard tool's `key` param description and tool description, and in run-sequence's args table. The run-sequence "type text and submit" example now shows the combined single-step form, since that is the pattern agents naturally reach for. ## Verification - New regression suite `test/keyboard-key-order.test.ts`: 6 tests asserting key-after-text ordering and fail-fast on unknown keys across all three branches. - Full tool-server suite: 1995/1996 pass — the single failure (`await-ui-element` Android `hidden` edge case) fails identically on clean `main`, as do the two `tsc` errors from a stale `@argent/telemetry` build.	2026-07-14 08:31:50 +02:00
Hubert Gancarczyk	fcf0ede624	feat(tool-server): settings-permissions tool to grant/deny/reset app permissions (#462) ... ## What Adds a `settings-permissions` MCP tool that edits an app's runtime permissions **out-of-band**, without navigating the system Settings UI. It's a test-setup / out-of-band tool — the default way to change a permission is still through the app (in-app toggle or the app-triggered dialog). Reach for this only when the app can't get there: - **pre-authorize** (`grant`) or **deny** a permission before the app asks, so no dialog interrupts the flow - **re-enable** one the user already denied (iOS never re-prompts once denied) - **reset** it so the first-run dialog reappears on next launch Supported permissions: camera, microphone, photos, contacts, notifications, calendar, location, location-always, media-library, motion, reminders. ## How **iOS simulator** — `xcrun simctl privacy grant|revoke|reset <service> [bundleId]`. - `notifications` has no simctl service → surfaced as an unsupported error. - An "invalid service" failure (e.g. `camera` on an Xcode that doesn't model it) is wrapped as unsupported with a hint to list supported services. - A shutdown simulator error carries a `boot-device` hint. **Android** — `pm grant` / `pm revoke` (plus `clear-permission-flags` on reset) over adb. - One abstract permission fans out to the concrete `android.permission.*` set (fine/coarse location, per-media reads); `location-always` grant also grants foreground location since background alone is unusable. - A `pm path` preflight rejects an uninstalled package (`pm grant`/`revoke` exit 0 for a missing package, which would otherwise report a false success). A transport-level adb failure is rethrown rather than mislabeled as "not installed" (`isTerminalAdbError` is now exported for this). - Partial results land in `skipped`; the action fails only when pm rejects **every** mapped permission. ## Supporting changes - New failure codes: `ANDROID_SETTINGS_PERMISSION_FAILED`, `IOS_SETTINGS_PERMISSION_FAILED`, `SETTINGS_PERMISSION_UNSUPPORTED`. - New `argent-settings-permissions` skill, plus cross-references from `argent-device-interact`, `argent-test-ui-flow`, and the argent rule (with a strong "prefer the app dialog over this tool" steer). - `bundleId` is regex-validated (same shell-injection guard as launch-app/restart-app) and schema-required for grant/deny. ## Testing `vitest` — **37/37 pass** (schema validation incl. shell-injection payloads, iOS branch, Android branch incl. partial/total pm failures and the preflight). `tsc --noEmit` clean for tool-server + registry + tests; prettier clean. --------- Co-authored-by: Filip131311 <contact@filipkaminski.com>	2026-07-13 22:45:06 +02:00
filip131311	2196cc18f0	feat(telemetry): anonymous crash diagnostics on toolserver:stop (#494) ... ## Why PostHog shows **~9,785 `toolserver:stop` crashes over 90 days**, but every one collapses into a single bucket — `error_kind=crash`, `error_code=TOOLSERVER_UNCAUGHT_EXCEPTION`. We know *that* the tool server died on a top-level throw, never *which* throw. The population is also two very different things we can't tell apart today: - **~99%** crash at **<5s uptime with 0 tool calls** — startup faults, and heavily concentrated per-user (top 10 users ≈ 31% of all crashes; one user logged 1,027), i.e. **boot → crash → relaunch loops**. - **~1,000** crash after **>10 min** of real serving — genuine runtime bugs. Without the actual exception, all 9,785 rows are unrankable and unfixable. ## What Four **crash-only, provably-anonymous** fields on `toolserver:stop`, enforced by the existing coded-allowlist sanitizer so **no free text can ever reach PostHog**: | field | value | why | |---|---|---| | `error_name` | error class name (`TypeError`, …) | "what kind" | | `error_syscall` | Node's `err.code` (`EADDRINUSE`, `ECONNREFUSED`, …) | the key discriminator for the startup-loop population (port/socket conflicts) | | `crash_fingerprint` | 16-hex hash of the **de-identified** top stack frames | clusters the same crash across users; input carries no identity, output is opaque | | `crash_phase` | `"startup"` \| `"serving"` | splits the two populations directly | Turns 9,785 opaque rows into a handful of rankable clusters. ## Anonymity (the hard requirement) - **No error message, no raw stack.** Those routinely embed `/Users/<name>/…`, URLs, argv, hostnames, interpolated values — the highest-PII surface and impossible to reliably scrub. The fingerprint replaces the message for clustering; `error_name` + `error_syscall` give the "what kind" without free text. - **Fingerprint input is de-identified before hashing** (defense-in-depth on top of the hash): first-party frames → basename only (drops the home-dir/project prefix), `node_modules` frames → package-relative tail (drops the user prefix; also collapses the pnpm `.pnpm/pkg@ver/` layout), `node:` internals kept verbatim, column dropped. So the *same crash on two machines produces the same fingerprint*, and no username/path survives even into the hash input. - **Sanitizer is the final gate.** `error_name` `^[A-Za-z][A-Za-z0-9_]{0,63}$`, `error_syscall` `^E[A-Z0-9_]{1,31}$`, `crash_fingerprint` `^[0-9a-f]{16}$`, `crash_phase` a 2-value enum. Any path/message/lowercase/oversize value is dropped before it can leave the machine. ## Scope & safety (no leaking crashes out of scope) - Fields are populated **only** in `crashShutdown` (which forces `reason="crash"`), so clean idle/signal stops carry none. Verified by the existing startup-telemetry test (the pre-listener watcher-rejection crash path stays the bare `{reason,uptime_ms,total_tool_calls}` shape). - The four keys exist only on `ToolserverStopProps` and only in the `toolserver:stop` allowlist entry — they can't ride any other event. - `describeCrash` is **total**: every field extraction is isolated, so a hostile throwing getter on `.name`/`.code`/`.stack` yields the phase (and whatever else is readable) instead of turning crash reporting into a second crash. The crash/exit guarantee — re-entrancy guard, force-exit timer, `finalExitCode` escalation — is untouched. ## Tests - New `crash-diagnostics.test.ts`: class-name/constructor-name/primitive extraction, syscall capture, cross-user determinism (incl. **Windows** drive-letter paths and **pnpm** layout), node_modules tail, line-sensitivity, no-stack omission, hostile-getter resilience, and "never emits a message/stack" confinement. - `sanitize.test.ts`: crash fields pass when well-formed; dropped for message-as-name, path/lowercase syscall, wrong-length/uppercase fingerprint, unknown phase; `ERR_*` accepted. - Full telemetry suite (278) + tool-server startup test green; lint/prettier clean. ## Reviewed Ran an adversarial review pass (anonymity leak-hunt, determinism, crash-path safety, scope). Ship-ready; all findings were Low/Nit and the actionable ones (hostile-getter hardening, Windows/pnpm test coverage, `error_syscall` doc clarity) are folded in. ### Deliberately deferred (documented, not blockers) - Sanitizer doesn't *cross-gate* the crash fields on `reason==="crash"` — the per-field validator design has no sibling access; coupling is enforced in emit code. The fields are non-identifying regardless, so a hypothetical stray `crash_phase` on an idle stop is a data nit, not a leak. - First-party frames reduce to basename; if `dist` ever ships unbundled with duplicate basenames, two sites at the same line could collide. Non-issue for the bundled tool-server.	2026-07-13 22:16:33 +02:00
Jakub Piasecki	551c781fb0	feat(flow): support running end-to-end flows without agent (#429) ... # Flow E2E This PR turns flows from replayable tool-call recordings into a declarative, portable e2e test system that runs headlessly via `argent flow run <name>` — no LLM in the loop, non-zero exit on failure, suitable for CI. Agents can still replay flows via `flow-execute` and get the full output from each step after it finishes. ## Flow format Flows are YAML files in `.argent/flows/`, now built from **directives** interpreted by the runner rather than raw tool calls: - `launch` — terminate + relaunch the app under test (per-platform app id map supported); its presence marks a flow as **e2e** (controls its own start state) vs. a **fragment** (runs against current state, declares an `executionPrerequisite`, composable via `run:` with cycle/depth guards). - `tap`, `type` (focus handshake + optional submit), `scroll-to` (momentum-free, increments by half the container, `within:` for nested scrollers), `await`/`assert` (`visible`/`exists`/`hidden`/`text` conditions), `wait`, `snapshot`, `echo`, and raw `tool:` as escape hatch — still fully supported, so previously recorded flows keep working unchanged. - **Selectors** are `{ text, identifier, role }`; a bare string is a loose selector resolving identifier-first, then visible text. Any directive failure hard-stops the flow; later steps report `skip`. ## Execution engine - Flows store no device id — the runner binds a device at replay (explicit `--device`/`--platform` or the single booted one). - Selector resolution runs against **platform-unified UI trees**: iOS native view hierarchy (full testID coverage, gated on native-devtools connecting), Android full accessibility hierarchy (full resource-id coverage), Chromium CDP DOM, and the Vega automation toolkit. A shared flatten/text-hoisting pass lets `text` assertions read what an identified container visibly shows. Vega is remote-driven, so touch directives fail with guidance to use `tv-remote`/`keyboard`. - Steps wait for the tree to **settle** (two consecutive identical reads) before acting; `launch` additionally gates on platform tree-source readiness instead of silently degrading. ## Visual snapshots `snapshot` diffs a full-resolution screenshot against baselines in `.argent/flows/__baselines__/<flow>/`, keyed by platform + resolution, with configurable `maxMismatch` and `--update-baselines`. The status bar is pinned for the whole run (iOS `simctl status_bar`, Android demo mode) so clocks/battery don't drive diffs. Baseline/current/diff images are returned as artifacts on failure (and the written baseline on first capture/update); a clean pass carries none, keeping reports and agent context lean. ## Recording The record-live workflow (`flow-start-recording` → `flow-add-step` → `flow-finish-recording`) now emits directives automatically: coordinate taps are rewritten to portable selector `tap:` steps (selector captured from the pre-tap tree), a leading `restart-app` becomes `launch:`, `flow-execute` of a sibling fragment becomes `run:`, and device ids are stripped. The skill instructs the agent to polish the saved YAML afterwards (fold tap+keyboard into `type:`, swipes-to-reach into `scroll-to:`, awaits into sugar form). ## Also included - `argent flow run` / `argent flow list` CLI with per-step report rendering, artifact materialization, and `--json` output. - New structured failure codes for flow validation, device resolution, composition, and devtools readiness. - Extensive unit test coverage (tree adapters, selector matching, scrolling, composition, type focus, snapshots, status bar).	2026-07-13 17:15:01 +02:00
Hubert Gancarczyk	f002fc9540	feat(telemetry): track Argent Lens design-review funnel (#478) ... ## What Adds three privacy-safe telemetry events for the Argent Lens design-review flow, capturing the human-decision funnel that the generic `tool:*` path can't see (submission is an HTTP POST, and the `await_user_selection` tool is hidden in `argent lens` CLI sessions): - **`lens:preview_opened`** — a human loaded the preview UI (`GET /preview/`), deduped per round. - **`lens:round_completed`** — the human submitted their picks (once per round, never on a resubmit). - **`lens:round_abandoned`** — a staged round was discarded before submit (window closed, `argent lens` exited mid-review, or the round superseded). ## Privacy Payloads carry only aggregate counts, booleans, durations, and the device `platform` enum — never element names, comment text, variant code, file paths, or raw device ids. The store emits privacy-safe aggregate structs that are decoupled from the telemetry package; structural assignability to the event props is enforced at the `track()` call site (drift is a compile error). ## Event fields - **`preview_opened`**: `round, element_count, variant_count, is_cli_session, platform` - **`round_completed`**: `round, element_count, variant_count, annotation_count, element_comment_count, skipped_comment_count, has_global_comment, is_cli_session, had_parked_await, round_duration_ms, platform` - **`round_abandoned`**: `round, element_count, variant_count, had_parked_await, is_cli_session, platform` ## Testing - Unit tests for all three events: per-round dedup, exactly-once completion (no resubmit re-emit), abandoned vs happy-path roll, CLI up-front open, and content-agnostic privacy assertions. - Verified end-to-end against a live tool-server: all three events fire with correct aggregate values and zero content leakage through the real sanitize pipeline. --------- Co-authored-by: Ignacy Łątka <latkaignacy@gmail.com>	2026-07-13 16:56:49 +02:00
Ignacy Łątka	a5c6730d05	feat(ios-profiler): attributable memory leaks via malloc_stack_logging (#351) ... ## What Opt-in `malloc_stack_logging` flag on `native-profiler-start` that makes iOS memory leaks **attributable** — they come back with a real responsible frame + library instead of `<Call stack limit reached>`. ## Why `native-profiler-start` attaches to the already-running app. iOS records malloc allocation backtraces only when `MallocStackLogging` is set **at process launch**, so an attached app has none: Instruments' Leaks scanner finds the leaked blocks but can't attribute them and emits the placeholder `<Call stack limit reached>` (that string is Instruments', not ours). ## How When `malloc_stack_logging: true`, the profiler cold-launches the app **under** xctrace instead of attaching: ``` xctrace record --template <Argent.tracetemplate> --device <udid> \ --env MallocStackLogging=1 --output <…> --no-prompt \ --launch -- <App.app> ``` - `.app` path resolved via `simctl get_app_container`; the running instance is terminated first for a clean cold start. - The existing Leaks export / parser / render path is reused **unchanged** — no parser changes. - Default behaviour is untouched: attach to the running app (no relaunch, no overhead). The flag is opt-in because it restarts the app (loses state) and adds allocator overhead — for leak-attribution passes, not CPU/hang work. - The report relabels unattributable leaks with a hint to re-run with `malloc_stack_logging: true`, instead of surfacing the raw placeholder. ## Evidence (real iPhone 16 sim, same scroll workload) Before (attach) — every leak row: ``` responsible-frame="<Call stack limit reached>" responsible-library="" ``` After (`--env MallocStackLogging=1 --launch`) — same Leaks export: | leaked-object | responsible-frame | library | |---|---|---| | Malloc 1008 B ×3 | `itanium_demangle::OutputBuffer::grow(...)` | libc++abi | | Malloc 48 B ×1 | `hermes::vm::JSTypedArrayBase::createBuffer(...)` | hermes | ## Tests - `test/ios-instruments/malloc-stack-logging.test.ts` — the malloc launch argv (`--env MallocStackLogging=1`, `--launch -- <app>` last, with and without `--notify-tracing-started`, `--no-prompt`) vs default `--attach`; terminate-first / get_app_container ordering; failed-start behavior; per-test `ARGENT_IOS_CAPTURE` scrubbing. - `test/ios-instruments/leak-attribution-render.test.ts` — unattributable vs attributed leak rendering, capture-mode-aware hints. - `test/ios-instruments/load-freshness.test.ts` — per-capture residue clearing on `profiler-load`, live/recovery-pending load refusals. - `test/ios-instruments/stop-recovery.test.ts` — capture-mode pairing at stop (clean and recovery paths). - `test/profiler-combined-leaks.test.ts`, `test/profiler-leak-stacks.test.ts`, `test/ios-leak-pipeline.test.ts` — shared caveat line, evidence-first hints, attribution-normalized grouping. - Full `test/ios-instruments/` suite green (9 files / 70 tests); full tool-server suite green; `tsc --noEmit` + `tsc -p tsconfig.test.json` clean. ## Notes E2E'd live twice during review (real iPhone 16 Pro / iPhone 17 Pro sims on Xcode 26.6): guard refusals fire before the app is touched, the `--device` cold launch's deadlock on degraded Xcode is confirmed (so the guard is warranted), and the malloc argv/terminate/relaunch behavior checked out on-device. Docs updated: `IOS_PROFILER_REFERENCE.md` and the `argent-native-profiler` skill. ## Review follow-ups (post-approval hardening) Later commits address the remaining review threads and several subsequent multi-lens review passes: - **Capture-mode is a real signal, end to end.** The session records the mode of the in-flight recording at start (`recordingMallocStackLogging`), pairs it with `exportedFiles` at stop (`mallocStackLogging`), and freezes it into `parsedData` at analyze/load — so the analyze report, the combined report, and the `leak_stacks` drill-down all name the capture mode of the data they actually render instead of inferring it (or mislabeling it after a newer capture starts). One shared `renderUnattributedLeaksNote()` keeps the wording identical across reports, and attribution evidence outranks the flag: a resolved frame proves the target ran under malloc stack logging however it was launched. - **`profiler-load` restores a clean slate.** Loading clears all per-capture residue (capture mode, `cpuFilterPid`, `wallClockStartMs`, `traceFile`) so a loaded trace is never analyzed with a previous live capture's PID filter, freshness anchor, or report path — and refuses to load while a recording is in flight or a crashed capture awaits `native-profiler-stop`'s partial-trace recovery, which the load would otherwise orphan. - **Failed starts are non-destructive.** Per-capture descriptors — and the recovery flags that gate `native-profiler-stop`'s partial-trace export — are stamped/reset only on a successful start, so a failed attempt leaves the previous capture's still-loaded exports fully described and a pending abnormal-end recovery intact. - **Guards keep session state coherent.** `profiler-load`, `native-profiler-analyze`, and `profiler-combined-report` all refuse while a recording is in flight or a crashed capture awaits recovery, via one shared `isCaptureInFlight`/`inFlightGuardMessage` helper whose message distinguishes recording vs 10-min-cap timeout vs unexpected exit (so the stated cause matches what `native-profiler-stop` reports next). Proceeding would otherwise wedge the session (load) or render one capture's frozen data under another's live fields (analyze/combined). - **The combined report anchors on a frozen clock.** The recording's start time is frozen into `parsedData` at analyze, and the iOS combined report anchors its hangs to that frozen value rather than the live session field — so a capture started after analyze can never shift a real hang↔commit correlation into "unmatched". Android keeps its live anchor (it re-derives hangs from the live trace). The combined-report guard's recovery advice routes through `native-profiler-analyze`, the only step that rebuilds `parsedData`. - **Leak grouping is attribution-normalized.** `aggregateLeaks` keys on `(objectType, frame-normalized-the-way-isLeakAttributed-matches)`, so mixed unattributed spellings (`Unknown`, the sentinel, whitespace variants) can't split one group per type. - **The malloc launch target is unambiguous.** Since the cold launch terminates the resolved app, `app_process` resolution prefers an exact `CFBundleExecutable` match and, when builds still tie (dev + prod sharing an executable/display name), refuses and points at the globally-unique `CFBundleIdentifier` — which it also accepts as an `app_process` — instead of killing whichever app the plist enumerates first. - **Report tables escape `|`.** Demangled C++ frames (`operator|` included) are real headline content under malloc mode; every free-form cell across the leak, CPU-hotspot, function caller/callee, and thread-breakdown tables — symbol *and* thread/queue-name columns — is escaped so a stray pipe can't shift the row's columns. - **Android start is non-destructive too.** `startNativeProfilerAndroid` now starts perfetto before mutating session state, mirroring iOS, so a failed start no longer burns a prior capped capture's pending partial-trace recovery.	2026-07-12 13:42:23 +02:00
Ignacy Łątka	44b38d490e	fix(tool-server): inject Android keyboard/button over adb input (#449) (#455) ... ## What & why `keyboard` and `button` drive Android through the simulator-server's USB-HID transport (`pressKey` / `cmd:"button"`). The guest only receives those HID events when the AVD exposes a hardware keyboard (`hw.keyboard = yes`) — the default, but CI / headless AVDs are routinely created with `hw.keyboard = no` (and `hw.mainKeys = no`), where the guest **silently drops** them. Because that transport is fire-and-forget, both tools returned `{ typed }` / `{ pressed }` **success while injecting nothing**. This still affects current `main`: after the keyboard refactor, `makeAndroidImpl` routes Android **TV** to `adb input` but Android **phones/tablets** still to `typeSimulatorServer` (the HID path). Fixes #449 (found during 0.13.0 RC E2E testing on a `hw.keyboard=no` AVD — `argent-test-ci-repro`, the config CI uses). ## Change Route Android **phone/tablet** key / text / button injection through `adb shell input text` and `input keyevent` (new `utils/android-input.ts`), the same on-device transport Android TV and Vega already use: - **`keyboard`** — `platforms/android.ts` now sends the non-TV branch to a `typeAndroidPhone` helper (adb `input`); the Android-TV and iOS branches are untouched. - **`button`** — the Android branch presses via `injectAndroidKeycode`; iOS keeps the simulator-server HID path. `adb input` lands regardless of `hw.keyboard`, on emulators (any config) and physical devices alike, and a non-zero exit surfaces as a **thrown error** instead of a silent no-op — directly addressing the fire-and-forget concern already called out in the `button` tool. Touch gestures are unchanged. ## Verification - **Unit tests — 11/11 pass** (rebased on current `main`): new `keyboard-android.test.ts` (vocabulary parity vs `NAMED_KEYS`, `input text` shell-quoting incl. spaces, `input keyevent` mapping, empty-text no-op, newline rejection) + updated `button.test.ts` (Android `back` now asserts `KEYCODE_BACK` over adb). - **eslint** on the changed files: clean. - **Live tool-server** on a `hw.keyboard=no` AVD: the `keyboard` tool now issues `adb … shell input text '…'` (vs the RC's HID `pressKey`), and a failed inject **raises an error** rather than a fake success. The `adb input` path was independently observed typing/deleting on this exact AVD during RC testing (where the HID path silently no-op'd). - Note: a full `tsc --build` / whole-suite run couldn't be completed in my environment (the `argent-private` submodule isn't checked out, which breaks the npm workspace install, and `main` added upstream deps my base lacked). `platforms/android.ts` mirrors the existing `platforms/ios.ts` branch structure one-for-one, and the pre-rebase revision of this change passed `tsc --build` + eslint. CI here is authoritative for the full typecheck. ## Reviewer notes - `input text` receives the string as one shell-quoted argv token, so spaces are preserved verbatim; newlines are rejected (they'd truncate the `input` line) — callers use `key: "enter"`. - `keys` counts by codepoint, matching the tv/vega/simulator-server backends.	2026-07-10 12:51:24 +02:00
Ignacy Łątka	b1cadd7cd6	fix(native-devtools): terminal state for non-injectable Apple system apps (#459) ... Fixes #453 ## The bug For an app that can never be injected (an Apple built-in app such as `com.apple.Preferences`), `native-devtools-status` kept reporting `requiresRestart: true` / `nextLaunchWillBeInjected: true`, and the native-* feature tools (native-describe-screen, native-find-views, etc.) kept returning "restart-app then retry". Restarting never changes the state, so an autonomous agent loops `restart-app → retry` forever. There was no terminal "this app cannot be injected" signal. ## Why these apps can't inject Apple system/built-in apps (bundle ids under `com.apple.`) are platform binaries with library validation enabled; the simulator ignores `DYLD_INSERT_LIBRARIES` for them, so the Argent native devtools dylib can never load. This is a reliable, well-understood signal on the simulator. Third-party apps the user installs carry no such restriction and inject fine. So the fix treats bundle ids starting with `com.apple.` as non-injectable, via a general predicate rather than hardcoding the single bundle id from the issue. ## The fix - New pure predicate `isInjectableBundleId(bundleId)` in `blueprints/native-devtools.ts` returning `false` for `com.apple.*` bundle ids (case-sensitive prefix, matching how bundle ids are compared), with a doc comment explaining the library-validation rationale. - New failure code `NATIVE_DEVTOOLS_NOT_INJECTABLE` in `@argent/registry`. - `precheckNativeDevtools(api, udid, bundleId)` (the 3-arg overload) now throws a terminal `FailureError` with that code, *before* the `requiresAppRestart → restart_required` branch, when the bundle id is non-injectable. Because every native-* feature tool awaits this precheck and propagates the throw, all 7 tools now surface a hard, terminal error instead of an unbounded restart→retry instruction — no change needed in the individual tool files. The 2-arg overload (no bundleId), used by `native-devtools-status`, is unchanged and never throws (guarded by `bundleId !== undefined`). - `native-devtools-status` now *reports* the state instead of throwing: it adds an `injectable: boolean` field. For a non-injectable app it returns `injectable: false, requiresRestart: false, nextLaunchWillBeInjected: false` (with `envSetup`/`appRunning`/`connected` still measured), giving an agent that checks status first a terminal signal. The tool description documents the new field and that `injectable: false` is terminal (do not restart/retry; use the standard describe / screenshot / view-at-point tools). ## Verification - `npm run build` (root tsc): clean. - `vitest run` on `native-devtools-status.test.ts`: 13/13 passing. Added coverage for the predicate, the status terminal state for a `com.apple.*` app, and that the 3-arg precheck throws `NATIVE_DEVTOOLS_NOT_INJECTABLE` while the 2-arg overload does not throw for the same api. - Telemetry `sanitize.test.ts` (iterates every registered failure code): 49/49 passing — the new code is accepted. - Prettier + eslint (`--max-warnings 0`) clean on all touched files. Device E2E on an iOS simulator with `com.apple.Preferences` (confirming `native-devtools-status` returns `injectable: false` and the native-* tools return the terminal error rather than looping restart-app) is pending and will be run separately. --- ### Device verification (iOS 18.5 simulator, com.apple.Preferences) Reproduced before/after on a real simulator with a dev tool-server: **Before (origin/main):** `native-devtools-status` for `com.apple.Preferences` → `requiresRestart:true, nextLaunchWillBeInjected:true`; `native-describe-screen` → `restart_required`; after `restart-app` the status is identical (the infinite loop). **After (this branch):** - `native-devtools-status` → `{envSetup:true, appRunning:true, connected:false, requiresRestart:false, nextLaunchWillBeInjected:false, injectable:false}` — terminal. - `native-describe-screen` / `native-find-views` → terminal error: "com.apple.Preferences is an Apple system app ... can never be injected ... use the standard describe / screenshot / view-at-point tools instead." (no more restart→retry loop). **Regression (injectable third-party app `xyz.blueskyweb.app`):** `native-devtools-status` → `injectable:true` with the normal `requiresRestart:true`; `native-describe-screen` → the normal `restart_required` (not the terminal error). The predicate does not false-positive on normal apps. --- ### Review follow-ups (@hubgan on-device review) - **Recovery guidance no longer recommends `view-at-point`.** Both view-at-point tools run this same 3-arg precheck and re-throw `NATIVE_DEVTOOLS_NOT_INJECTABLE` for a `com.apple.*` bundle, so recommending them dead-ended the agent. All three surfaces (the precheck throw, the `describe` iOS fallback hint, and the `native-devtools-status` description) now share one verbatim "do not fall back to the native-* tools" warning (`NON_INJECTABLE_NATIVE_WARNING`) and recommend only `describe` and `screenshot`. (52b888ce) - **Propagation tests for all six feature tools.** Added tests that drive each 3-arg feature tool's `execute()` with a `com.apple.*` bundle and assert the throw propagates out as `NATIVE_DEVTOOLS_NOT_INJECTABLE`, so a future try/catch inside a tool can't silently regress the terminal behavior (proven non-vacuous via a swallow-the-throw mutation). (52b888ce) - **Degraded sim + system app keeps the re-boot hint.** When the ax-service is degraded, `describe` now returns the `boot-device force=true` guidance instead of the terminal screenshot hint - a proper re-boot may let the ax-service read the system app's full tree. `should_restart` is still never set, so the restart loop stays removed. (5ace8be3) --- ### Second review round (@hubgan) + follow-up hardening - **Terminal check hoisted above env init in the precheck.** Injectability is a static property of the bundle id, so the `NATIVE_DEVTOOLS_NOT_INJECTABLE` throw now fires before the `givenUp`/`ensureEnvReady` plumbing - a broken env can no longer mask the terminal signal behind `init_failed`'s re-boot guidance, and no env work is spent on a system app. Regression tests cover both masked paths. (ca7093c6) - **The same ordering applied to the other two surfaces.** `native-devtools-status` computes the injectable gate before the precheck (a given-up sim no longer hides `injectable: false` behind `init_failed`), and `describe`'s gate moved ahead of native-devtools service resolution (a downed ios-remote tunnel or dispose race no longer swallows the terminal hint). (bef6dfcb) - **Unreachable-sim fallback.** If the status tool's `isAppRunning` probe fails on a non-injectable app (shut-down sim), it falls back to the precheck so a broken sim still surfaces structured `init_failed` - whose re-boot guidance IS corrective there - instead of a raw subprocess error; a healthy env rethrows the probe failure. (722b432a) - **Warning text scoped to the tools it is true of.** `NON_INJECTABLE_NATIVE_WARNING` now names the six injection-based feature tools instead of sweeping in all `native-*` tools - the `native-profiler-*` tools never inject and keep working on system apps. (bef6dfcb) - **launch-app / restart-app boundary pinned.** New tests drive both tools (local iOS and ios-remote dispatch, all four call sites) with `com.apple.Preferences` and the real precheck, asserting the terminal throw never reaches them - proven non-vacuous by a 3-arg mutation failing exactly the mutated sites. (bef6dfcb, 722b432a)	2026-07-10 12:51:05 +02:00
Gabe Debes	10a78d0527	feat(file-inputs): add tar-upload kind for streaming remote file/directory uploads (#443) ... ## What A new `tar-upload` file-input kind so a tool that reads a local file or directory (e.g. `reinstall-app`'s app bundle) works when the tool-server runs on a different machine than the caller. ## Why `reinstall-app` assumes the bundle is on the tool-server's filesystem. That breaks with a cloud-hosted simulator — the bundle is on your machine, not the server's. The existing `file` kind inlines base64 and is capped at 32 MB, too small for a real `.app`/`.apk`; `tar-upload` streams instead. ## How When you're not linked to a remote server, an existing local path is used in place. When you are (e.g. `argent link`), the client tars the path, streams it to `POST /upload`, and the tool call carries `uploadId` plus a SHA-256 `contentHash`. The server always extracts from that upload — even if the same path already exists on disk — verifies the hash, and vets tar members before extracting. The client only uploads when the path is on its own machine (a line on stderr so you know it's working). Same command local or remote: ``` argent run reinstall-app --udid <udid> --bundleId <id> --appPath ./MyApp.app ``` ## Shared extraction Per review feedback, the tar pack/unpack logic is unified in a small `@argent/archive` package used by **both** directions — this upload path and the pre-existing artifact download (`streamDirectoryAsTarGz` / `downloadAndExtractArchive`). The shared extractor rejects path-traversal entries, symlinks whose target escapes the extract dir, and non-file/dir members (hardlinks, devices) — while still allowing a bundle's internal symlinks. This also hardens the artifact-download path, which previously extracted without those checks. ## Tests Client + server unit and HTTP round-trip tests: dir and file upload, skip-when-not-local, co-located no-op, hash required, path-traversal / escaping-symlink / hardlink rejection, sidecar handling, single-member resolution, `/upload` auth + size caps, and artifact download extraction. All suites pass. --------- Co-authored-by: Filip131311 <contact@filipkaminski.com>	2026-07-10 12:29:48 +02:00
Stanisław Chmiela	a7775e4ba6	feat(tool-server): add tool-server event log (#367) ... We want to display a nicely parsed and rendered log of events that happened over a span of an Argent session. Current log file is not designed to be machine-readable, so adding a JSONL-formatted log of events (gated by `tool-server-event-log`). I eventually want this 😋 https://x.com/j3nnings/status/2069072177584849192 When enabled, the tool server writes Bunyan-compatible records to `ARGENT_EVENT_LOG` or `~/.argent/tool-server-events.jsonl`. The log captures tool-server lifecycle events and registry lifecycle events, including tool invocations and others. To make messages nicer, added `interaction` object to tool definition. This allows tools to define a nicer message in log (print "Screenshot capture completed." instead of "Tool `screenshot` completed.") Adding these to the existing tools is a follow up PR matter I think.	2026-07-10 11:52:28 +02:00
filip131311	2a01e407b3	chore: release 0.15.0 (submodule + workspace bump) (#484) ... ## What - Bump the `packages/argent-private` submodule pointer from `v0.11.0-8-g2953e89` to **v0.15.0** (`41484e4`). The superproject pin had drifted ~4 releases behind the checked-out submodule. - Lockstep-bump all `packages/*` workspace packages from `0.14.0` → **0.15.0** (and the matching `package-lock.json` entries) to line up with the submodule. ## Why The submodule and the workspace were out of sync: the working tree had `argent-private` checked out at v0.15.0 while the superproject still pinned the v0.11 era, and the JS packages sat at 0.14.0. This adopts v0.15.0 as the single, consistent version across the repo. ## Verification - `node scripts/check-workspace-versions.mjs` → `All workspace packages are at 0.15.0.` - `git submodule status` → clean (no `+`), pinned at `v0.15.0`. - Lockfile diff is exactly 15 version-field swaps (no unrelated churn).	2026-07-08 17:31:45 +02:00
Juliusz Wajgelt	8cde990c05	fix(tool-server): pass MoQ auth token on remote connect URL (#481) ... ## Problem radon-cloud's ARG-208 auth change token-gates remote simulator MoQ sessions: sim-server now rejects any MoQ session that doesn't present the per-acquire lease token as a `?token=` query param on the WebTransport connect URL (the relay forwards it verbatim end-to-end). Argent's MoQ client never attached the token, so remote connections broke. ## Fix - Add `token` to the `MoqInfo` shape returned by `sim-remote moq-info`. - In `openMoqClientFromInfo`, set `?token=` on the connect URL before `Connection.connect`, mirroring the radon-cloud webui (`useMoQ.ts`). The guard keeps older `sim-remote` binaries (no `token` field) from producing a literal `token=undefined`. No transport change was needed — the client already connects over WebTransport (`@moq/net` + `@fails-components/webtransport` polyfill), and `@moq/net` passes the URL query through to `new WebTransport(...)`.	2026-07-08 17:24:13 +02:00
filip131311	4d34a689b5	feat(tool-server): add ARGENT_SIMULATOR_NO_WINDOW to force headless iOS boots (#483) ... ## What Adds `ARGENT_SIMULATOR_NO_WINDOW` — the iOS analog of the existing Android `ARGENT_EMULATOR_NO_WINDOW` env var — to force local iOS simulator boots to run headless. ## Why `ARGENT_EMULATOR_NO_WINDOW=1` already makes Android emulators boot headless host-wide (appends `-no-window`). iOS had no env-var equivalent: it could only boot headless via the per-call `headless: true` parameter on the `boot-device` tool, which is awkward for CI/containers and Argent Lens hosts that stream every device through `simulator-server` and never want a window. Note: `simctl boot` is already headless at the core — the only thing that pops a window is the `open -a Simulator.app` GUI attach at the end of `bootIos`. This env var gates exactly that step. ## Changes - `boot-device.ts` - New `iosHeadlessFromEnv()` helper next to Android's `selectExtraEmulatorArgs()`, with identical truthy parsing (`1`/`true`/`yes`, case-insensitive). - `bootIos` GUI-attach gate changed from `if (!headless)` → `if (!headless && !iosHeadlessFromEnv())`. - Updated the `headless` param docs to mention the env var. - `boot-device.test.ts` — new test asserting `Simulator.app` is not opened when `ARGENT_SIMULATOR_NO_WINDOW` is set (env saved/restored around the test). ## Scope Applies to the local iOS path (`bootIos`). The remote path (`bootIosRemote` via `sim-remote`) has no local `Simulator.app` step, so it's unaffected. ## Testing - `npx tsc --noEmit` — clean - `npx vitest run test/boot-device.test.ts` — 23/23 pass (incl. the new test)	2026-07-08 17:22:31 +02:00
filip131311	7bd017a796	feat(installer): committable repo-local (--local) install mode (#428) ... ## Summary Adds an opt-in **committable / repo-local** install mode so a team can version Argent _with the repo_. `argent init --local` installs `@swmansion/argent` as a project **devDependency** and writes MCP configs that launch the project-local copy — so after `git clone && npm install`, every teammate has the same Argent version and MCP wiring with **no global install and no per-developer `argent init`**. **Global mode stays the default** and is unchanged; everything here is additive and backward-compatible. Motivation: the workflow some users already do by hand (#207). Supersedes the earlier, since-closed #232 — this version is Windows-safe (`node`, not the `.bin` shim), handles Yarn PnP, and closes the cross-install tool-server hazards rather than leaving them. ## What changed **`init`** - `--local` / `--global` flags + an interactive "How should argent be installed?" prompt. Mutually exclusive; non-interactive (`--yes`) defaults to **global**. - Local mode installs the devDependency with the package manager detected from the project's **lockfile** (run with `cwd = projectRoot`). - MCP entry points at the local copy: `node node_modules/@swmansion/argent/dist/cli.js mcp` (the bin path is derived from the installed `package.json` `bin` and existence-checked — forward slashes, committable, Windows-safe). Yarn PnP → `yarn argent mcp`; an `npx --no-install argent mcp` fallback is used only when the bin can't be resolved. - Records the mode in a committed `<root>/.argent/install.json`. - Drops global-only adapters (Windsurf/Hermes) in local mode; prints team-setup / commit guidance. **`update`** — detects the project's mode; in local mode reads the installed version from `node_modules` (not the global binary / npx cache) and bumps the **devDependency + lockfile**, then re-emits the local MCP command. **`uninstall`** — scoped to the project's mode: a local-mode uninstall removes the **local devDependency only and never the shared global install**, and prunes `.argent/install.json`. Global-mode behavior is unchanged. **Cross-install hardening (the gate that makes per-project pinning safe)** - `launcher`: a tool-server is reused only when its `bundlePath` matches the caller's — a repo-local pin never silently runs against (or kills) a different version's server. - `postinstall`: only stops a tool-server spawned from *this package's own* bundle, so a devDependency install can't tear down an unrelated editor session. **Telemetry** — adds an `install_mode` dimension to init/update/uninstall events. ## Testing - New unit tests: install-mode helpers + record (`utils`), mode-aware `getMcpEntry`/`resolveLocalCommandMode` incl. the opencode array form (`mcp-configs`), local-only uninstall guard (`uninstall`), and bundlePath-gated tool-server reuse (`launcher`). - All existing suites green (installer 346, tools-client 115, telemetry 191, registry 83, argent 13, tool-server 1621). Build + lint clean. - **Live end-to-end** in an isolated sandbox: `init --local` → real MCP stdio handshake serves **69 tools from `node_modules`**; `update --local` reads the local version; `uninstall --local` removes the local install and **leaves the global install intact**; `init --global` unchanged; flag conflict rejected. ## Notes / known limitations - Recommended on mainstream platforms (macOS, Linux x64, Windows x64) with prebuilt native binaries; Linux arm64 / Windows arm need a C/C++ toolchain to build `tree-sitter` on `npm install` (documented in the README). - Concurrent sessions of two *different* Argent versions on one machine each spawn their own tool-server; an orphaned one idle-times-out (no session is ever broken). 🤖 Generated with [Claude Code](https://claude.com/claude-code)	2026-07-08 12:24:19 +02:00
Hubert Gancarczyk	f38f0e3876	feat(telemetry): distinguish tvOS and Android TV from iOS/Android (#477) ... ## Summary Telemetry inferred the device platform purely from device-id **shape** on the per-tool-call hot path, so a tvOS simulator (same 8-4-4-4-12 UUID as an iPhone) and an Android TV emulator (same `emulator-NNNN` serial as a phone) were both reported as `ios` / `android` — TV usage was invisible in analytics. This adds `tvos` and `android-tv` to the **telemetry** `PLATFORMS` enum and refines the inference so a TV target is attributed correctly. ## Approach - The runtime kind (`mobile` / `tv`) is already resolved and memoized in two module-level caches (`runtimeKindCache` in `ios-devices.ts`, `androidRuntimeKindCache` in `adb.ts`), warmed by the usual TV-path tools (describe, screenshot, keyboard, launch/restart-app, the streaming blueprint, tv-control). - New synchronous, **cache-only** readers (`getCachedSimulatorRuntimeKind`, `getCachedAndroidRuntimeKind`) let `refineTvPlatform` in `http.ts` map `ios → tvos` / `android → android-tv` with **no new `simctl`/`adb` round-trip** on the hot path. - The registry **device** `Platform` (`@argent/registry`) is intentionally left unchanged — a TV stays a `runtimeKind`, not its own device platform, so capability gating and dispatch remain TV-agnostic. The two new values are confined to the telemetry boundary (`tool:invoke` / `tool:complete` / `tool:fail` and child sub-tool attribution). ## Behavior notes - The **first** tool call on a device may land before the cache is warm and reports the coarse base platform (`ios`/`android`); subsequent calls, once describe/screenshot/streaming have run, report the TV variant. This is best-effort coarse telemetry by design. - For an `emulator-NNNN` slot reclaimed by a different-form-factor AVD within one tool-server lifetime, the synchronous reader can momentarily report the prior occupant's kind until an async, avdName-checked path re-probes. Documented inline; no crash and no dispatch impact. ## Verification - **Live E2E** against real booted devices (real `simctl`/`adb` → real cache → real http telemetry recording): Apple TV → `tvos` (cold-cache `ios`, warm `tvos`); iPhone → `ios`; Android phone → `android`. The `android-tv` path is symmetric and covered by unit/integration tests with real leanback-feature probing. - Unit + integration tests added: sanitize allowlist, http platform inference (cold/warm/TV/child), and cache readers. Telemetry suite 192/192; tool-server affected suites green. - `tsc` build, `typecheck:tests`, eslint (`--max-warnings 0`), and prettier all clean.	2026-07-07 16:29:22 +02:00