feat: runner-aware tools by branchseer · Pull Request #346 · voidzero-dev/vite-task

branchseer · 2026-04-18T10:39:04Z

Give task runners a bidirectional IPC channel with the processes they spawn, so:

tools can declare at runtime what inputs they actually read / outputs they actually produced
tools can request additional env vars be tracked (or not) in the cache key
tools can tell the runner "don't cache me this time"
the runner feeds all of that back into its caching decisions

Design notes: docs/runner-task-ipc/.

What's in this PR

Step 1 — Protocol (vite_task_ipc_shared): message types + serialization shared by both ends.
Step 2 — Transport (vite_task_server + vite_task_client): async server, sync blocking client, tested Rust-to-Rust.
Step 3 — Extract artifact crate out of fspy for dylib embedding. (Landed on main via refactor: extract materialized_artifact crate out of fspy #344 as materialized_artifact.)
Step 4 — JS bridge: vite_task_client_napi + @voidzero-dev/vite-task-client JS wrapper (with fetchEnvs dedupe logic).
Step 5 — Runner integration: server started per task execution, client dylib embedded/extracted, IPC envs injected via serve()'s returned iterator.
Step 6 — Cache integration: runner consumes reported ignored inputs/outputs, tracked env requests, and disable-cache signals when fingerprinting.

Test plan

Rust integration tests for server/client transport (vite_task_server/tests/integration.rs)
NAPI e2e tests (vite_task_client_napi/tests/e2e.rs)
E2E snapshot fixtures per client method: ignore_input, ignore_output, fetch_env, disable_cache
E2E test caching a real vite build via a patched Vite plugin (vite_build_cache fixture)

branchseer · 2026-04-20T02:19:35Z

Warning

This pull request is not mergeable via GitHub because a downstack PR is open. Once all requirements are satisfied, merge this PR as a stack on Graphite.
Learn more

feat: runner-aware tools #346 👈 (View in Graphite)
feat(cache): restore output files on cache hit #321
main

This stack of pull requests is managed by Graphite. Learn more about stacking.

- vite_task_ipc_shared: shared protocol (Request/GetEnvResponse, NativeStr) - vite_task_server: per-task IPC server (Handler trait + Recorder) - vite_task_client: sync Rust client - vite_task_client_napi + @voidzero-dev/vite-task-client: node addon + JS wrapper - vite_task: wire IPC server into spawn; inject VP_IPC + VP_RUN_NODE_CLIENT_PATH; bundle with fspy via Tracking struct; materialize .node addon on first use Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Step 6 of docs/runner-task-ipc/plan.md. - Apply `ignoreInputs` to filter inferred fspy reads (directory-aware) - Apply `ignoreOutputs` to filter auto-detected writes (overlap check + archive) - Short-circuit cache update on `disableCache()` via new `CacheNotUpdatedReason::ToolRequested` - Embed `tracked: true` envs in `PostRunFingerprint.tracked_envs`; validate on lookup by comparing against the current parent env - Recorder env_map sources from `std::env::vars_os()` so tools can resolve envs the user never declared - Bump cache schema to 13 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

New fixture `ipc_client_test` exercises each IPC method through the JS wrapper (@voidzero-dev/vite-task-client) inside a real cached task: - ignoreInput → the ignored dir can mutate without invalidating cache - ignoreOutput → read-write overlap under an ignored dir still caches - disableCache → forces re-execution on next run - fetchEnv(tracked: true) → env change invalidates cache; same value hits The e2e harness now copies packages/vite-task-client into each staging node_modules so fixtures can `import { ... } from "@voidzero-dev/vite-task-client"` without pnpm install. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Applies a small pnpm patch to vite 8.0.8 that auto-injects a runner-aware plugin at plugin-resolution time. When `VP_RUN_NODE_CLIENT_PATH` is set (i.e. the child runs under `vp run`), the plugin: - `ignoreInput(outDir)` — suppress fspy reads of the output dir (emptyDir scans dist/ before writing) - `ignoreInput/Output(<root>/node_modules)` — machine state (pnpm store + vite's `.vite`/`.vite-temp` caches) is not user input/output - `getEnv("NODE_ENV", true)` — tracked; drives DCE and define replacements New e2e fixture `vite_build_cache` proves `vt run --cache build` produces a cache hit on the second run and restores `dist/assets/main.js` after deletion, all with zero manual input/output configuration. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…Extensions Rework `patches/vite.patch` to match the shape of the eventual upstream Vite PR: - Drop the synthetic `vite:runner-aware` plugin. Each IPC call is now inlined right at the Vite code that triggers the fs / env access: - `ignoreInput(outDir)` in `prepareOutDir` before `emptyDir` scans it - `ignoreInput(depsCacheDir)` + `ignoreOutput(depsCacheDir)` in `loadCachedDepOptimizationMetadata` before the dep optimizer cache is read / written - `fetchEnv("NODE_ENV", { tracked: true })` in `resolveConfig` before `process.env.NODE_ENV` is first consulted - `ignoreInput`/`ignoreOutput` of `.vite-temp/` in `loadConfigFromBundledFile` (bundled-config temp write+import) - Static `import` of `@voidzero-dev/vite-task-client` by name — the wrapper no-ops when no runner is connected, so no guard is needed at the call sites. - Add a `packageExtensions` entry in `pnpm-workspace.yaml` that injects the wrapper as a real dependency of Vite. The final upstream PR would instead declare it in `packages/vite/package.json`; the only delta between experiment and PR is that one line. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

The previous snapshot embedded Vite's minified JS output, which would churn on every Vite version bump. Add a tiny `vtt stat-file` helper that reports `exists` / `missing` and use that instead. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>