Snapshot capture failure (EPERM spawning git) fails the whole step despite the best-effort contract #58685

Activity

1. opencode-agent commented on Oct 24, 2026

   

   opencode-agentBot

   on Oct 24, 2026 – with OpenCode Agent

   Contributor

   More actions

   Thanks for the detailed analysis. I reproduced it on the v2.0.26 source and on the latest dev (f20760b) using a test, without a real Windows machine.

   The script below makes spawning git throw synchronously with EPERM: operation not permitted, uv_spawn 'git', which matches the error in your stack trace. The first Snapshot.capture() returns a tree ID. The next one, with spawn throwing, does not return undefined as the best-effort contract says. It fails with the EPERM error coming out of Git.tree.capture, which gets past the Effect.catch handler.

   The throw seems to come from launchProcess in packages/util/src/cross-spawn-spawner.ts. It calls cross-spawn without a try/catch, and only async error events become typed errors. On Linux, Bun reports spawn errors such as EACCES asynchronously, so they are handled there. The synchronous throw seems specific to how Bun spawns processes on Windows.

   I didn't run a full session step here. That this then ends the turn silently comes from your log.

   Reproduction script (snapshot-spawn-throw.test.ts)

   // Reproduction for anomalyco/opencode#58685.
   // Run from packages/core of an opencode checkout:
   //   cp snapshot-spawn-throw.test.ts packages/core/test/ && cd packages/core && bun test test/snapshot-spawn-throw.test.ts
   // Simulates a spawn() that throws synchronously (as Bun does on Windows for
   // `EPERM: operation not permitted, uv_spawn 'git.EXE'`) and checks that the
   // best-effort Snapshot.capture returns undefined instead of dying.
   import { mock, describe, expect } from "bun:test"
   import { $ } from "bun"
   import fs from "fs/promises"
   import path from "path"
   import { Cause, Effect, Exit, Layer } from "effect"
   
   let failSpawn = false
   // cross-spawn is a dependency of @opencode/util, which launches every child process through it.
   const crossSpawn = Bun.resolveSync("cross-spawn", path.dirname(Bun.resolveSync("@opencode/util/process", import.meta.dir)))
   const real = (await import(crossSpawn)).default
   mock.module(crossSpawn, () => {
     const launch: any = (cmd: string, args: string[], opts: any) => {
       if (failSpawn && /git/i.test(cmd)) {
         const err: any = new Error(`EPERM: operation not permitted, uv_spawn '${cmd}'`)
         err.code = "EPERM"
         err.syscall = "spawn"
         throw err
       }
       return real(cmd, args, opts)
     }
     launch.spawn = launch
     launch.sync = real.sync
     return { default: launch }
   })
   
   const { AppNodeBuilder } = await import("@opencode/core/effect/app-node-builder")
   const { Global } = await import("@opencode/util/global")
   const { Location } = await import("@opencode/core/location")
   const { AbsolutePath } = await import("@opencode/core/schema")
   const { Snapshot } = await import("@opencode/core/snapshot")
   const { tmpdir } = await import("./fixture/tmpdir")
   const { testEffect } = await import("./lib/effect")
   
   describe("Snapshot best-effort capture (#58685)", () => {
     testEffect(Layer.empty).live("returns undefined when spawning git throws", () =>
       Effect.acquireUseRelease(
         Effect.promise(() => tmpdir()),
         (tmp) =>
           Effect.gen(function* () {
             const project = path.join(tmp.path, "project")
             yield* Effect.promise(async () => {
               await fs.mkdir(project)
               await fs.writeFile(path.join(project, "a.txt"), "one\n")
               await $`git init`.cwd(project).quiet()
             })
             const layer = AppNodeBuilder.build(Snapshot.node, [
               Location.node.replace(Location.boundNode(Location.Ref.make({ directory: AbsolutePath.make(project) }))),
               Global.node.replace(Global.layerWith({ data: tmp.path, config: path.join(tmp.path, "config") })),
             ])
             yield* Effect.gen(function* () {
               const snapshot = yield* Snapshot.Service
               const first = yield* snapshot.capture()
               console.log("first capture (spawn ok):", first)
               expect(first).toBeDefined()
   
               failSpawn = true
               const exit = yield* Effect.exit(snapshot.capture())
               failSpawn = false
               if (Exit.isFailure(exit)) console.log("second capture (spawn throws) DIED:\n" + Cause.pretty(exit.cause))
               else console.log("second capture (spawn throws) returned:", exit.value)
               expect(Exit.isSuccess(exit)).toBe(true)
               if (Exit.isSuccess(exit)) expect(exit.value).toBeUndefined()
             }).pipe(Effect.provide(layer))
           }),
         (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
       ),
     )
   })

   Run it: bun snapshot-spawn-throw.test.ts
2. opencode-agent

   added

   reproduced

   on Oct 24, 2026
3. Dopetaiga commented on Oct 24, 2026

   

   Dopetaiga

   on Oct 24, 2026

   More actions

   I'd like to take this. Plan: the best-effort handler at snapshot.ts uses Effect.catch, which in Effect v4 recovers typed failures only — a spawn failure from child_process arrives as a defect and sails past it into the step. Add Effect.catchDefect alongside so the documented contract (log a warning, return undefined, keep the step alive) holds for both channels; interruption still propagates. Will verify with a defect-injection repro of the exact handler shape.
4. Dopetaiga

   added a commit that references this issue on Oct 25, 2026

   fix(util): type a synchronous spawn refusal through the PlatformError…

   ...

   7a282f9
5. Dopetaiga

   added a commit that references this issue on Nov 9, 2026

   fix(util): type a synchronous spawn refusal through the PlatformError…

   ...

   fb52715