fix: Windows grep outage and test-run telemetry pollution

Two production defects found in Azure telemetry over 2026-07-22 → 2026-08-05.

**Windows `grep` broken for 99 machines**

`core_failure` showed 328 events across 99 distinct Windows machines (of 617
total) carrying `? is not recognized as an internal or external command,
operable program or batch file.` and its German, French, Spanish and Portuguese
translations. Present on released 0.9.2, 0.9.3 and 0.9.4.

Root cause: ripgrep's Windows release is a zip, and `RipgrepBinary` extracted it
via `powershell.exe -Command Expand-Archive`, falling back to the literal string
`"powershell.exe"` when neither `powershell.exe` nor `pwsh.exe` resolved.
`cross-spawn`'s `parseNonShell()` sets `needsShell = true` when `resolveCommand()`
returns undefined and re-spawns through `cmd.exe /d /s /c`, so cmd.exe produced
that message. `throw new Error(result.stderr.trim())` made it the error verbatim,
and since `RipgrepBinary.filepath` is `Effect.cached`, one failed extraction broke
grep for the whole session.

Upstream carries the same fragility: anomalyco/opencode#24291 is open, reporting
`Expand-Archive` unusable when spawned from the Bun-compiled binary, affecting
`grep`, `glob` and `skill`. Their #23457 fix only corrected how paths were passed
to PowerShell (the `$args` → inlined-and-escaped form we already carry); it did
not remove the dependency on PowerShell being resolvable.

Extract the zip in-process with `@zip.js/zip.js`, converging on the approach the
`packages/opencode/src/file/ripgrep.ts` shim already uses in production.
`unzipExecutable` is exported so archive handling is tested directly, and decodes
with `checkSignature: true` — zip.js defaults it off, and a CRC-corrupt download
would otherwise be written to the cache and trusted by every later session.

Install the binary atomically (stage to `rg.exe.tmp`, then rename). `filepath`
trusts the cached binary on existence alone, so an interrupted write previously
left a truncated `rg.exe` that every later session reused — the same permanent
breakage `checkSignature` guards against, which CRC cannot catch because it is
verified before the write. The tar path installs the same way.

Attribute resolution failures. Child stderr was reported verbatim, so a
shell-level failure was indistinguishable from a tool bug; and because a resolve
failure is memoized, it is re-reported on every later grep in the session. The tar
branch now names ripgrep, and any typed filesystem or HTTP failure is wrapped as
`ripgrep binary resolve failed: …`.

Note the blast radius is wider than the `grep` tool: `@opencode-ai/core/ripgrep`
also backs the HTTP-API file handlers and `cli/cmd/debug/ripgrep.ts`.

**Test runs shipped telemetry to the production resource**

1,020 of 3,135 machine ids in the same window emitted `provider_id="test"` /
`cli_version="local"` — test processes that regenerate their machine id every
run, inflating install and active-machine counts by roughly a third. `doInit()`
gated only on `ALTIMATE_TELEMETRY_DISABLED`.

Refuse the baked-in connection string when `NODE_ENV=test`, `BUN_TEST`, `VITEST`
or `JEST_WORKER_ID` is set. Keyed on test runners, deliberately not on CI:
`altimate-code-actions` wraps this CLI, so every run of that shipped product sets
`CI`/`GITHUB_ACTIONS`, and gating on those would blind a real product surface.
`bun test` sets `NODE_ENV=test`, which covers CI and developer machines alike.
An explicit `APPLICATIONINSIGHTS_CONNECTION_STRING` is always honoured, so suites
with their own sink are unaffected; `ALTIMATE_TELEMETRY_FORCE=true` overrides the
default-sink refusal, and the existing opt-outs still win over both.

Test plan: 8 ripgrep tests — including a layer-level test that drives `filepath`
through the Windows zip path with a spawner that fails if invoked, asserting the
staged-then-renamed install, and a CRC case that fails without `checkSignature` —
plus 15 telemetry-gate tests covering CI-alone-still-reports and one that relies
on the real runner's `NODE_ENV`. `turbo typecheck` green, marker guard green,
`packages/core` and `packages/opencode` suites show no failures beyond the
pre-existing set on `main`.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: anandgupta42

bun.lock

@@ -126,6 +126,24 @@ export ALTIMATE_TELEMETRY_DISABLED=true
 
 When telemetry is disabled, no events are sent and no network requests are made to the telemetry endpoint.
 
+### Test runs are excluded
+
+Test runners never reach the default telemetry endpoint. Telemetry is suppressed when `NODE_ENV=test`,
+`BUN_TEST`, `VITEST`, or `JEST_WORKER_ID` is present. This exists because test processes regenerate
+their machine ID on every run, so without the exclusion they dominate install and active-machine counts.
+
+Running in CI is **not** excluded — that is ordinary product usage (for example
+[altimate-code-actions](https://github.com/AltimateAI/altimate-code-actions) wraps this CLI), so
+`CI` and `GITHUB_ACTIONS` on their own do not suppress anything.
+
+Two escape hatches exist for reporting from a test run deliberately:
+
+- Set `APPLICATIONINSIGHTS_CONNECTION_STRING` to your own endpoint — an explicitly-configured sink
+  is always honoured, which is how the project's own telemetry tests work.
+- Set `ALTIMATE_TELEMETRY_FORCE=true` to use the default endpoint anyway.
+
+`ALTIMATE_TELEMETRY_DISABLED` and the config opt-out take precedence over both.
+
 ## Privacy
 
 We take your privacy seriously. Altimate Code telemetry **never** collects:

docs/docs/reference/telemetry.md

@@ -97,6 +97,7 @@
     "@opentelemetry/sdk-trace-base": "2.6.1",
     "@parcel/watcher": "2.5.1",
     "@silvia-odwyer/photon-node": "0.3.4",
+    "@zip.js/zip.js": "2.7.62",
     "@openrouter/ai-sdk-provider": "2.9.0",
     "ai-gateway-provider": "3.1.2",
     "bun-pty": "0.4.8",

packages/core/package.json

@@ -140,7 +140,11 @@ export const layer = Layer.effect(
             return yield* new InvalidPatternError({ pattern: input.pattern, message: stderr.trim() })
           }
           if (code !== 0 && code !== 1 && code !== 2) {
-            return yield* failure(stderr.trim() || `ripgrep failed with code ${code}`)
+            // altimate_change start — upstream_fix: keep child stderr attributable to ripgrep.
+            // Reporting stderr verbatim made shell-level failures (e.g. a Windows "not recognized"
+            // message) look like they came from the tool itself, with no hint of the real source.
+            return yield* failure(`ripgrep failed with code ${code}: ${stderr.trim() || "no output"}`)
+            // altimate_change end
           }
           return { items: code === 1 ? [] : rows, truncated: false, partial: code === 2 }
         }),

packages/core/src/ripgrep.ts

@@ -9,6 +9,10 @@ import { httpClient } from "../effect/layer-node-platform"
 import { FSUtil } from "../fs-util"
 import { Global } from "../global"
 import { which } from "../util/which"
+// altimate_change start — upstream_fix: unzip in-process instead of shelling out to PowerShell.
+import { randomUUID } from "node:crypto"
+import { BlobReader, BlobWriter, ZipReader } from "@zip.js/zip.js"
+// altimate_change end
 
 export namespace RipgrepBinary {
   const VERSION = "15.1.0"
@@ -26,6 +30,48 @@ export namespace RipgrepBinary {
     readonly filepath: Effect.Effect<string, Error>
   }
 
+  // altimate_change start — upstream_fix: unzip in-process instead of shelling out to PowerShell.
+  // Windows is the only platform that ships ripgrep as a zip, and the previous `Expand-Archive`
+  // implementation needed a resolvable powershell.exe/pwsh.exe. When neither resolved (locked-down
+  // or non-English corporate images), cross-spawn silently re-spawned through `cmd.exe /d /s /c`,
+  // which answers "'powershell.exe' is not recognized as an internal or external command". That
+  // string became the thrown Error verbatim; `filepath` is Effect.cached, so one failed extraction
+  // broke grep for the rest of the session. Telemetry showed 99 Windows machines stuck on this.
+  // Decoding in-process removes the external dependency entirely. Upstream has the same fragility
+  // open as anomalyco/opencode#24291 (Expand-Archive unusable from a Bun-spawned process) — their
+  // #23457 fix only corrected how the paths were passed to PowerShell, not the dependency on it.
+  /** Decode the `rg` executable out of a ripgrep release zip. Exported for tests. */
+  export const unzipExecutable = Effect.fnUntraced(function* (bytes: ArrayBuffer) {
+    const reader = new ZipReader(new BlobReader(new Blob([bytes])))
+
+    // The reader stays open across both getEntries() and getData() — closing after the first would
+    // release it while entry reads are still outstanding.
+    return yield* Effect.gen(function* () {
+      const entries = yield* Effect.tryPromise({
+        try: () => reader.getEntries(),
+        catch: (cause) => new Error(`ripgrep archive could not be read: ${cause}`),
+      })
+
+      // Release zips nest the binary under `ripgrep-<version>-<platform>/`, but match a bare
+      // `rg.exe` too so a flattened or repackaged archive still works.
+      const entry = entries.find((x) => !x.directory && /(^|[\\/])rg\.exe$/i.test(x.filename))
+      if (!entry?.getData) return yield* Effect.fail(new Error("ripgrep archive did not contain rg.exe"))
+
+      // checkSignature defaults to false in zip.js, which would let a CRC-corrupt download decode
+      // "successfully". The bytes are then written to Global.Path.bin and trusted by every later
+      // session purely because the file exists — a corrupt download would break grep permanently,
+      // which is the failure class this change exists to remove.
+      const blob = yield* Effect.tryPromise({
+        try: () => entry.getData!(new BlobWriter(), { checkSignature: true }),
+        catch: (cause) => new Error(`ripgrep archive entry could not be decoded: ${cause}`),
+      })
+      const decoded = yield* Effect.promise(() => blob.arrayBuffer())
+      if (decoded.byteLength === 0) return yield* Effect.fail(new Error("ripgrep archive contained an empty rg.exe"))
+      return new Uint8Array(decoded)
+    }).pipe(Effect.ensuring(Effect.promise(() => reader.close()).pipe(Effect.ignore)))
+  })
+  // altimate_change end
+
   export class Service extends Context.Service<Service, Interface>()("@opencode/RipgrepBinary") {}
 
   export const layer = Layer.effect(
@@ -48,34 +94,60 @@ export namespace RipgrepBinary {
         return { stdout, stderr, code }
       }, Effect.scoped)
 
-      const extract = Effect.fnUntraced(function* (
+      // altimate_change start — upstream_fix: install the binary atomically.
+      // `target` is the cache path every later session trusts on existence alone
+      // (`fs.isFile(target)` below — no size or integrity check). A write interrupted partway
+      // therefore leaves a truncated `rg.exe` that is reused forever, which is the same
+      // "permanently broken until the cache is deleted by hand" failure this change exists to
+      // remove — and `checkSignature` cannot help, since CRC is verified before the write.
+      // Staging next to the target keeps the rename within one filesystem, so it is atomic.
+      const install = Effect.fnUntraced(
+        function* (target: string, write: (staged: string) => Effect.Effect<void, Error>) {
+          // Staging name is unique per attempt. A shared `${target}.tmp` lets two cold-cache
+          // processes clobber each other: one renames while the other is still writing, so the
+          // loser publishes a partial binary or renames a file that no longer exists.
+          const staged = `${target}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`
+          yield* Effect.gen(function* () {
+            yield* write(staged)
+            if (process.platform !== "win32") yield* fs.chmod(staged, 0o755)
+            // POSIX rename replaces atomically. Windows fails when the destination exists, so
+            // retry once after removing it — but only after the first attempt has failed, so a
+            // rename that fails for any other reason leaves the existing binary untouched.
+            yield* fs.rename(staged, target).pipe(
+              Effect.catch(() =>
+                Effect.gen(function* () {
+                  yield* fs.remove(target, { force: true }).pipe(Effect.ignore)
+                  yield* fs.rename(staged, target)
+                }),
+              ),
+            )
+          }).pipe(Effect.onError(() => fs.remove(staged, { force: true }).pipe(Effect.ignore)))
+        },
+        // Name the failure. A resolve failure is memoized by Effect.cached, so it is re-reported on
+        // every later grep of the session — an unattributed filesystem message there is what made
+        // the Windows outage read as a tool bug rather than a binary problem.
+        Effect.mapError((cause) => {
+          const message = cause instanceof Error ? cause.message : String(cause)
+          return /ripgrep/i.test(message) ? cause : new Error(`ripgrep binary install failed: ${message}`)
+        }),
+      )
+      // altimate_change end
+
+      // altimate_change start — upstream_fix: tar.gz path only; zip is handled by unzipExecutable.
+      const extractTar = Effect.fnUntraced(function* (
         archive: string,
         config: (typeof PLATFORM)[keyof typeof PLATFORM],
         target: string,
       ) {
         const dir = yield* fs.makeTempDirectoryScoped({ directory: Global.Path.bin, prefix: "ripgrep-" })
 
-        if (config.extension === "zip") {
-          const shell = (yield* Effect.sync(() => which("powershell.exe") ?? which("pwsh.exe"))) ?? "powershell.exe"
-          const result = yield* run(shell, [
-            "-NoProfile",
-            "-NonInteractive",
-            "-Command",
-            `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -LiteralPath '${archive.replaceAll("'", "''")}' -DestinationPath '${dir.replaceAll("'", "''")}' -Force`,
-          ])
-          if (result.code !== 0)
-            throw new Error(
-              result.stderr.trim() || result.stdout.trim() || `ripgrep extraction failed with code ${result.code}`,
-            )
-        }
-
-        if (config.extension === "tar.gz") {
-          const result = yield* run("tar", ["-xzf", archive, "-C", dir])
-          if (result.code !== 0)
-            throw new Error(
-              result.stderr.trim() || result.stdout.trim() || `ripgrep extraction failed with code ${result.code}`,
-            )
-        }
+        const result = yield* run("tar", ["-xzf", archive, "-C", dir])
+        // Attribute the failure to ripgrep extraction rather than reporting child stderr verbatim —
+        // an unattributed shell string is what made the Windows outage undiagnosable.
+        if (result.code !== 0)
+          throw new Error(
+            `ripgrep extraction failed with code ${result.code}: ${result.stderr.trim() || result.stdout.trim() || "no output"}`,
+          )
 
         const extracted = path.join(
           dir,
@@ -84,9 +156,9 @@ export namespace RipgrepBinary {
         )
         if (!(yield* fs.isFile(extracted))) throw new Error(`ripgrep archive did not contain executable: ${extracted}`)
 
-        yield* fs.copyFile(extracted, target)
-        if (process.platform !== "win32") yield* fs.chmod(target, 0o755)
+        yield* install(target, (staged) => fs.copyFile(extracted, staged))
       }, Effect.scoped)
+      // altimate_change end
 
       return Service.of({
         filepath: yield* Effect.cached(
@@ -103,20 +175,40 @@ export namespace RipgrepBinary {
 
             const filename = `ripgrep-${VERSION}-${config.platform}.${config.extension}`
             const url = `https://github.com/BurntSushi/ripgrep/releases/download/${VERSION}/${filename}`
-            const archive = path.join(Global.Path.bin, filename)
 
             yield* Effect.logInfo("downloading ripgrep", { url })
             yield* fs.ensureDir(Global.Path.bin).pipe(Effect.orDie)
             const bytes = yield* HttpClientRequest.get(url).pipe(
               http.execute,
               Effect.flatMap((response) => response.arrayBuffer),
-              Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause)))),
+              // altimate_change start — upstream_fix: name the download failure.
+              // A bare HttpClientError/ResponseError says nothing about ripgrep, and because
+              // `filepath` is Effect.cached it is then re-reported on every later grep of the
+              // session — a network block or proxy 403 would read as a grep bug.
+              Effect.mapError((cause) => {
+                const message = cause instanceof Error ? cause.message : String(cause)
+                return /ripgrep/i.test(message)
+                  ? cause instanceof Error
+                    ? cause
+                    : new Error(message)
+                  : new Error(`ripgrep download failed from ${url}: ${message}`)
+              }),
+              // altimate_change end
             )
             if (bytes.byteLength === 0) throw new Error(`failed to download ripgrep from ${url}`)
 
-            yield* fs.writeWithDirs(archive, new Uint8Array(bytes))
-            yield* extract(archive, config, target)
-            yield* fs.remove(archive, { force: true }).pipe(Effect.ignore)
+            // altimate_change start — upstream_fix: zip extracts in-process, no PowerShell.
+            // The staging archive only exists on the tar path, so its cleanup lives there too.
+            if (config.extension === "zip") {
+              const decoded = yield* unzipExecutable(bytes)
+              yield* install(target, (staged) => fs.writeWithDirs(staged, decoded))
+            } else {
+              const archive = path.join(Global.Path.bin, filename)
+              yield* fs.writeWithDirs(archive, new Uint8Array(bytes))
+              yield* extractTar(archive, config, target)
+              yield* fs.remove(archive, { force: true }).pipe(Effect.ignore)
+            }
+            // altimate_change end
             return target
           }),
         ),