@miaws/miaw 1.18.5 → 1.18.6

package/test/tool/shell.test.ts

@@ -1,1238 +0,0 @@
-import { PermissionV1 } from "@miaw/core/v1/permission"
-import { describe, expect } from "bun:test"
-import { Cause, Effect, Exit, Layer } from "effect"
-import type * as Scope from "effect/Scope"
-import os from "os"
-import path from "path"
-import { Config } from "@/config/config"
-import { Shell } from "@miaw/core/shell"
-import { ShellTool } from "../../src/tool/shell"
-import { Filesystem } from "@/util/filesystem"
-import { provideInstance, testInstanceStoreLayer, tmpdirScoped } from "../fixture/fixture"
-import type { Permission } from "../../src/permission"
-import { Agent } from "../../src/agent/agent"
-import { Truncate } from "@/tool/truncate"
-import { SessionID, MessageID } from "../../src/session/schema"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { FSUtil } from "@miaw/core/fs-util"
-import { Plugin } from "../../src/plugin"
-import { testEffect } from "../lib/effect"
-import { Tool } from "@/tool/tool"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import { InstanceStore } from "@/project/instance-store"
-
-const shellLayer = Layer.mergeAll(
-  CrossSpawnSpawner.defaultLayer,
-  FSUtil.defaultLayer,
-  Plugin.defaultLayer,
-  Truncate.defaultLayer,
-  Config.defaultLayer,
-  Agent.defaultLayer,
-  RuntimeFlags.defaultLayer,
-  testInstanceStoreLayer,
-)
-const it = testEffect(shellLayer)
-type ShellTestServices =
-  | (typeof shellLayer extends Layer.Layer<infer ROut, infer _E, infer _RIn> ? ROut : never)
-  | InstanceStore.Service
-  | Scope.Scope
-
-const initShell = Effect.fn("ShellToolTest.init")(function* () {
-  const info = yield* ShellTool
-  return yield* info.init()
-})
-
-const initBash = initShell
-
-const run = Effect.fn("ShellToolTest.run")(function* (
-  args: Tool.InferParameters<typeof ShellTool>,
-  next: Tool.Context = ctx,
-) {
-  const bash = yield* initShell()
-  return yield* bash.execute(args, next)
-})
-
-const runIn = <A, E, R>(directory: string, self: Effect.Effect<A, E, R>) => self.pipe(provideInstance(directory))
-
-const fail = Effect.fn("ShellToolTest.fail")(function* (
-  args: Tool.InferParameters<typeof ShellTool>,
-  next: Tool.Context = ctx,
-) {
-  const exit = yield* run(args, next).pipe(Effect.exit)
-  if (Exit.isFailure(exit)) {
-    const err = Cause.squash(exit.cause)
-    return err instanceof Error ? err : new Error(String(err))
-  }
-  throw new Error("expected command to fail")
-})
-
-const ctx = {
-  sessionID: SessionID.make("ses_test"),
-  messageID: MessageID.make("msg_test"),
-  callID: "",
-  agent: "build",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-}
-
-Shell.acceptable.reset()
-const quote = (text: string) => `"${text}"`
-const squote = (text: string) => `'${text}'`
-const projectRoot = path.join(__dirname, "../..")
-const bin = quote(process.execPath.replaceAll("\\", "/"))
-const bash = (() => {
-  const shell = Shell.acceptable()
-  if (Shell.name(shell) === "bash") return shell
-  return Shell.gitbash()
-})()
-const shells = (() => {
-  if (process.platform !== "win32") {
-    const shell = Shell.acceptable()
-    return [{ label: Shell.name(shell), shell }]
-  }
-
-  const list = [bash, Bun.which("pwsh"), Bun.which("powershell"), process.env.COMSPEC || Bun.which("cmd.exe")]
-    .filter((shell): shell is string => Boolean(shell))
-    .map((shell) => ({ label: Shell.name(shell), shell }))
-
-  return list.filter(
-    (item, i) => list.findIndex((other) => other.shell.toLowerCase() === item.shell.toLowerCase()) === i,
-  )
-})()
-const PS = new Set(["pwsh", "powershell"])
-const ps = shells.filter((item) => PS.has(item.label))
-const cmdShell = shells.find((item) => item.label === "cmd")
-
-const sh = () => Shell.name(Shell.acceptable())
-const evalarg = (text: string) => (sh() === "cmd" ? quote(text) : squote(text))
-
-const fill = (mode: "lines" | "bytes", n: number) => {
-  const code =
-    mode === "lines"
-      ? "console.log(Array.from({length:Number(Bun.argv[1])},(_,i)=>i+1).join(String.fromCharCode(10)))"
-      : "process.stdout.write(String.fromCharCode(97).repeat(Number(Bun.argv[1])))"
-  const text = `${bin} -e ${evalarg(code)} ${n}`
-  if (PS.has(sh())) return `& ${text}`
-  return text
-}
-const glob = (p: string) =>
-  process.platform === "win32" ? Filesystem.normalizePathPattern(p) : p.replaceAll("\\", "/")
-
-const forms = (dir: string) => {
-  if (process.platform !== "win32") return [dir]
-  const full = Filesystem.normalizePath(dir)
-  const slash = full.replaceAll("\\", "/")
-  const root = slash.replace(/^[A-Za-z]:/, "")
-  return Array.from(new Set([full, slash, root, root.toLowerCase()]))
-}
-
-const withShell = <A, E, R>(item: { label: string; shell: string }, self: Effect.Effect<A, E, R>) =>
-  Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const prev = process.env.SHELL
-      process.env.SHELL = item.shell
-      Shell.acceptable.reset()
-      Shell.preferred.reset()
-      return prev
-    }),
-    () => self,
-    (prev) =>
-      Effect.sync(() => {
-        if (prev === undefined) delete process.env.SHELL
-        else process.env.SHELL = prev
-        Shell.acceptable.reset()
-        Shell.preferred.reset()
-      }),
-  )
-
-const each = (
-  name: string,
-  fn: (item: { label: string; shell: string }) => Effect.Effect<void, unknown, ShellTestServices>,
-) => {
-  for (const item of shells) {
-    it.live(`${name} [${item.label}]`, () => withShell(item, fn(item)))
-  }
-}
-
-const capture = (requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">>, stop?: Error) => ({
-  ...ctx,
-  ask: (req: Omit<PermissionV1.Request, "id" | "sessionID" | "tool">) =>
-    Effect.sync(() => {
-      requests.push(req)
-      if (stop) throw stop
-    }),
-})
-
-const mustTruncate = (result: {
-  metadata: { truncated?: boolean; exit?: number | null } & Record<string, unknown>
-  output: string
-}) => {
-  if (result.metadata.truncated) return
-  throw new Error(
-    [`shell: ${process.env.SHELL || ""}`, `exit: ${String(result.metadata.exit)}`, "output:", result.output].join("\n"),
-  )
-}
-
-describe("tool.shell", () => {
-  each("basic", () =>
-    runIn(
-      projectRoot,
-      Effect.gen(function* () {
-        const result = yield* run({
-          command: "echo test",
-          description: "Echo test message",
-        })
-        expect(result.metadata.exit).toBe(0)
-        expect(result.metadata.output).toContain("test")
-      }),
-    ),
-  )
-
-  it.live("falls back from terminal-only configured shell", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped({ config: { shell: "fish" } })
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const bash = yield* initBash()
-          const fallback = Shell.name(Shell.acceptable("fish"))
-          expect(fallback).not.toBe("fish")
-          expect(bash.description).toContain(fallback)
-
-          const result = yield* bash.execute(
-            {
-              command: "echo fallback",
-              description: "Echo fallback text",
-            },
-            ctx,
-          )
-          expect(result.metadata.exit).toBe(0)
-          expect(result.output).toContain("fallback")
-        }),
-      )
-    }),
-  )
-})
-
-describe("tool.shell permissions", () => {
-  each("asks for bash permission with correct pattern", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          yield* run(
-            {
-              command: "echo hello",
-              description: "Echo hello",
-            },
-            capture(requests),
-          )
-          expect(requests.length).toBe(1)
-          expect(requests[0].permission).toBe("bash")
-          expect(requests[0].patterns).toContain("echo hello")
-        }),
-      )
-    }),
-  )
-
-  each("asks for bash permission with multiple commands", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          yield* run(
-            {
-              command: "echo foo && echo bar",
-              description: "Echo twice",
-            },
-            capture(requests),
-          )
-          expect(requests.length).toBe(1)
-          expect(requests[0].permission).toBe("bash")
-          expect(requests[0].patterns).toContain("echo foo")
-          expect(requests[0].patterns).toContain("echo bar")
-        }),
-      )
-    }),
-  )
-
-  for (const item of ps) {
-    it.live(`parses PowerShell conditionals for permission prompts [${item.label}]`, () =>
-      withShell(
-        item,
-        runIn(
-          projectRoot,
-          Effect.gen(function* () {
-            const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-            yield* run(
-              {
-                command: "Write-Host foo; if ($?) { Write-Host bar }",
-                description: "Check PowerShell conditional",
-              },
-              capture(requests),
-            )
-            const bashReq = requests.find((r) => r.permission === "bash")
-            expect(bashReq).toBeDefined()
-            expect(bashReq!.patterns).toContain("Write-Host foo")
-            expect(bashReq!.patterns).toContain("Write-Host bar")
-            expect(bashReq!.always).toContain("Write-Host *")
-          }),
-        ),
-      ),
-    )
-  }
-
-  for (const item of ps) {
-    it.live(`uses PowerShell cmdlet prefixes for always-allow prompts [${item.label}]`, () =>
-      withShell(
-        item,
-        Effect.gen(function* () {
-          const tmp = yield* tmpdirScoped()
-          yield* runIn(
-            tmp,
-            Effect.gen(function* () {
-              const err = new Error("stop after permission")
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              expect(
-                yield* fail(
-                  {
-                    command: "Remove-Item -Recurse tmp",
-                    description: "Remove a temp directory",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-              const bashReq = requests.find((r) => r.permission === "bash")
-              expect(bashReq).toBeDefined()
-              expect(bashReq!.always).toContain("Remove-Item *")
-              expect(bashReq!.always).not.toContain("Remove-Item -Recurse *")
-            }),
-          )
-        }),
-      ),
-    )
-  }
-
-  each("asks for external_directory permission for wildcard external paths", () =>
-    runIn(
-      projectRoot,
-      Effect.gen(function* () {
-        const err = new Error("stop after permission")
-        const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-        const file = process.platform === "win32" ? `${process.env.WINDIR!.replaceAll("\\", "/")}/*` : "/etc/*"
-        const want = process.platform === "win32" ? glob(path.join(process.env.WINDIR!, "*")) : "/etc/*"
-        expect(
-          yield* fail(
-            {
-              command: `cat ${file}`,
-              description: "Read wildcard path",
-            },
-            capture(requests, err),
-          ),
-        ).toMatchObject({ message: err.message })
-        const extDirReq = requests.find((r) => r.permission === "external_directory")
-        expect(extDirReq).toBeDefined()
-        expect(extDirReq!.patterns).toContain(want)
-      }),
-    ),
-  )
-
-  if (process.platform === "win32") {
-    if (bash) {
-      it.live("asks for nested bash command permissions [bash]", () =>
-        withShell(
-          { label: "bash", shell: bash },
-          Effect.gen(function* () {
-            const outerTmp = yield* tmpdirScoped()
-            yield* Effect.promise(() => Bun.write(path.join(outerTmp, "outside.txt"), "x"))
-            yield* runIn(
-              projectRoot,
-              Effect.gen(function* () {
-                const file = path.join(outerTmp, "outside.txt").replaceAll("\\", "/")
-                const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-                yield* run(
-                  {
-                    command: `echo $(cat "${file}")`,
-                    description: "Read nested bash file",
-                  },
-                  capture(requests),
-                )
-                const extDirReq = requests.find((r) => r.permission === "external_directory")
-                const bashReq = requests.find((r) => r.permission === "bash")
-                expect(extDirReq).toBeDefined()
-                expect(extDirReq!.patterns).toContain(glob(path.join(outerTmp, "*")))
-                expect(bashReq).toBeDefined()
-                expect(bashReq!.patterns).toContain(`cat "${file}"`)
-              }),
-            )
-          }),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for PowerShell paths after switches [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const err = new Error("stop after permission")
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              expect(
-                yield* fail(
-                  {
-                    command: `Copy-Item -PassThru "${process.env.WINDIR!.replaceAll("\\", "/")}/win.ini" ./out`,
-                    description: "Copy Windows ini",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-              const extDirReq = requests.find((r) => r.permission === "external_directory")
-              expect(extDirReq).toBeDefined()
-              expect(extDirReq!.patterns).toContain(glob(path.join(process.env.WINDIR!, "*")))
-            }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for nested PowerShell command permissions [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              const file = `${process.env.WINDIR!.replaceAll("\\", "/")}/win.ini`
-              yield* run(
-                {
-                  command: `Write-Output $(Get-Content ${file})`,
-                  description: "Read nested PowerShell file",
-                },
-                capture(requests),
-              )
-              const extDirReq = requests.find((r) => r.permission === "external_directory")
-              const bashReq = requests.find((r) => r.permission === "bash")
-              expect(extDirReq).toBeDefined()
-              expect(extDirReq!.patterns).toContain(glob(path.join(process.env.WINDIR!, "*")))
-              expect(bashReq).toBeDefined()
-              expect(bashReq!.patterns).toContain(`Get-Content ${file}`)
-            }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for drive-relative PowerShell paths [${item.label}]`, () =>
-        withShell(
-          item,
-          Effect.gen(function* () {
-            const tmp = yield* tmpdirScoped()
-            yield* runIn(
-              tmp,
-              Effect.gen(function* () {
-                const err = new Error("stop after permission")
-                const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-                expect(
-                  yield* fail(
-                    {
-                      command: 'Get-Content "C:../outside.txt"',
-                      description: "Read drive-relative file",
-                    },
-                    capture(requests, err),
-                  ),
-                ).toMatchObject({ message: err.message })
-                expect(requests[0]?.permission).toBe("external_directory")
-                if (requests[0]?.permission !== "external_directory") return
-                expect(requests[0].patterns).toContain(glob(path.join(path.dirname(tmp), "*")))
-              }),
-            )
-          }),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for $HOME PowerShell paths [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const err = new Error("stop after permission")
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              expect(
-                yield* fail(
-                  {
-                    command: 'Get-Content "$HOME/.ssh/config"',
-                    description: "Read home config",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-              expect(requests[0]?.permission).toBe("external_directory")
-              if (requests[0]?.permission !== "external_directory") return
-              expect(requests[0].patterns).toContain(glob(path.join(os.homedir(), ".ssh", "*")))
-            }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for $PWD PowerShell paths [${item.label}]`, () =>
-        withShell(
-          item,
-          Effect.gen(function* () {
-            const tmp = yield* tmpdirScoped()
-            yield* runIn(
-              tmp,
-              Effect.gen(function* () {
-                const err = new Error("stop after permission")
-                const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-                expect(
-                  yield* fail(
-                    {
-                      command: 'Get-Content "$PWD/../outside.txt"',
-                      description: "Read pwd-relative file",
-                    },
-                    capture(requests, err),
-                  ),
-                ).toMatchObject({ message: err.message })
-                expect(requests[0]?.permission).toBe("external_directory")
-                if (requests[0]?.permission !== "external_directory") return
-                expect(requests[0].patterns).toContain(glob(path.join(path.dirname(tmp), "*")))
-              }),
-            )
-          }),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for $PSHOME PowerShell paths [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const err = new Error("stop after permission")
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              expect(
-                yield* fail(
-                  {
-                    command: 'Get-Content "$PSHOME/outside.txt"',
-                    description: "Read pshome file",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-              expect(requests[0]?.permission).toBe("external_directory")
-              if (requests[0]?.permission !== "external_directory") return
-              expect(requests[0].patterns).toContain(glob(path.join(path.dirname(item.shell), "*")))
-            }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for missing PowerShell env paths [${item.label}]`, () =>
-        withShell(
-          item,
-          Effect.acquireUseRelease(
-            Effect.sync(() => {
-              const key = "MIAW_TEST_MISSING"
-              const prev = process.env[key]
-              delete process.env[key]
-              return { key, prev }
-            }),
-            ({ key }) =>
-              runIn(
-                projectRoot,
-                Effect.gen(function* () {
-                  const err = new Error("stop after permission")
-                  const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-                  const root = path.parse(process.env.WINDIR!).root.replace(/[\\/]+$/, "")
-                  expect(
-                    yield* fail(
-                      {
-                        command: `Get-Content -Path "${root}$env:${key}\\Windows\\win.ini"`,
-                        description: "Read Windows ini with missing env",
-                      },
-                      capture(requests, err),
-                    ),
-                  ).toMatchObject({ message: err.message })
-                  const extDirReq = requests.find((r) => r.permission === "external_directory")
-                  expect(extDirReq).toBeDefined()
-                  expect(extDirReq!.patterns).toContain(glob(path.join(process.env.WINDIR!, "*")))
-                }),
-              ),
-            ({ key, prev }) =>
-              Effect.sync(() => {
-                if (prev === undefined) delete process.env[key]
-                else process.env[key] = prev
-              }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for PowerShell env paths [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              yield* run(
-                {
-                  command: "Get-Content $env:WINDIR/win.ini",
-                  description: "Read Windows ini from env",
-                },
-                capture(requests),
-              )
-              const extDirReq = requests.find((r) => r.permission === "external_directory")
-              expect(extDirReq).toBeDefined()
-              expect(extDirReq!.patterns).toContain(
-                Filesystem.normalizePathPattern(path.join(process.env.WINDIR!, "*")),
-              )
-            }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for PowerShell FileSystem paths [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const err = new Error("stop after permission")
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              expect(
-                yield* fail(
-                  {
-                    command: `Get-Content -Path FileSystem::${process.env.WINDIR!.replaceAll("\\", "/")}/win.ini`,
-                    description: "Read Windows ini from FileSystem provider",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-              expect(requests[0]?.permission).toBe("external_directory")
-              if (requests[0]?.permission !== "external_directory") return
-              expect(requests[0].patterns).toContain(
-                Filesystem.normalizePathPattern(path.join(process.env.WINDIR!, "*")),
-              )
-            }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`asks for external_directory permission for braced PowerShell env paths [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const err = new Error("stop after permission")
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              expect(
-                yield* fail(
-                  {
-                    command: "Get-Content ${env:WINDIR}/win.ini",
-                    description: "Read Windows ini from braced env",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-              expect(requests[0]?.permission).toBe("external_directory")
-              if (requests[0]?.permission !== "external_directory") return
-              expect(requests[0].patterns).toContain(
-                Filesystem.normalizePathPattern(path.join(process.env.WINDIR!, "*")),
-              )
-            }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`treats Set-Location like cd for permissions [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              yield* run(
-                {
-                  command: "Set-Location C:/Windows",
-                  description: "Change location",
-                },
-                capture(requests),
-              )
-              const extDirReq = requests.find((r) => r.permission === "external_directory")
-              const bashReq = requests.find((r) => r.permission === "bash")
-              expect(extDirReq).toBeDefined()
-              expect(extDirReq!.patterns).toContain(
-                Filesystem.normalizePathPattern(path.join(process.env.WINDIR!, "*")),
-              )
-              expect(bashReq).toBeUndefined()
-            }),
-          ),
-        ),
-      )
-    }
-
-    for (const item of ps) {
-      it.live(`does not add nested PowerShell expressions to permission prompts [${item.label}]`, () =>
-        withShell(
-          item,
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              yield* run(
-                {
-                  command: "Write-Output ('a' * 3)",
-                  description: "Write repeated text",
-                },
-                capture(requests),
-              )
-              const bashReq = requests.find((r) => r.permission === "bash")
-              expect(bashReq).toBeDefined()
-              expect(bashReq!.patterns).not.toContain("a * 3")
-              expect(bashReq!.always).not.toContain("a *")
-            }),
-          ),
-        ),
-      )
-    }
-  }
-
-  if (process.platform === "win32" && cmdShell) {
-    it.live("asks for external_directory permission for cmd file commands [cmd]", () =>
-      withShell(
-        cmdShell,
-        runIn(
-          projectRoot,
-          Effect.gen(function* () {
-            const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-            yield* run(
-              {
-                command: `TYPE "${path.join(process.env.WINDIR!, "win.ini")}"`,
-                description: "Read Windows ini with cmd",
-              },
-              capture(requests),
-            )
-            const extDirReq = requests.find((r) => r.permission === "external_directory")
-            expect(extDirReq).toBeDefined()
-            expect(extDirReq!.patterns).toContain(Filesystem.normalizePathPattern(path.join(process.env.WINDIR!, "*")))
-          }),
-        ),
-      ),
-    )
-  }
-
-  each("asks for external_directory permission when cd to parent", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const err = new Error("stop after permission")
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          expect(
-            yield* fail(
-              {
-                command: "cd ../",
-                description: "Change to parent directory",
-              },
-              capture(requests, err),
-            ),
-          ).toMatchObject({ message: err.message })
-          const extDirReq = requests.find((r) => r.permission === "external_directory")
-          expect(extDirReq).toBeDefined()
-        }),
-      )
-    }),
-  )
-
-  each("asks for external_directory permission when workdir is outside project", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const err = new Error("stop after permission")
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          expect(
-            yield* fail(
-              {
-                command: "echo ok",
-                workdir: os.tmpdir(),
-                description: "Echo from temp dir",
-              },
-              capture(requests, err),
-            ),
-          ).toMatchObject({ message: err.message })
-          const extDirReq = requests.find((r) => r.permission === "external_directory")
-          expect(extDirReq).toBeDefined()
-          expect(extDirReq!.patterns).toContain(glob(path.join(os.tmpdir(), "*")))
-        }),
-      )
-    }),
-  )
-
-  if (process.platform === "win32") {
-    it.live("normalizes external_directory workdir variants on Windows", () =>
-      Effect.gen(function* () {
-        const err = new Error("stop after permission")
-        const outerTmp = yield* tmpdirScoped()
-        const tmp = yield* tmpdirScoped()
-        yield* runIn(
-          tmp,
-          Effect.gen(function* () {
-            const want = Filesystem.normalizePathPattern(path.join(outerTmp, "*"))
-
-            for (const dir of forms(outerTmp)) {
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              expect(
-                yield* fail(
-                  {
-                    command: "echo ok",
-                    workdir: dir,
-                    description: "Echo from external dir",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-
-              const extDirReq = requests.find((r) => r.permission === "external_directory")
-              expect({ dir, patterns: extDirReq?.patterns, always: extDirReq?.always }).toEqual({
-                dir,
-                patterns: [want],
-                always: [want],
-              })
-            }
-          }),
-        )
-      }),
-    )
-
-    if (bash) {
-      it.live("uses Git Bash /tmp semantics for external workdir", () =>
-        withShell(
-          { label: "bash", shell: bash },
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const err = new Error("stop after permission")
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              const want = glob(path.join(os.tmpdir(), "*"))
-              expect(
-                yield* fail(
-                  {
-                    command: "echo ok",
-                    workdir: "/tmp",
-                    description: "Echo from Git Bash tmp",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-              expect(requests[0]).toMatchObject({
-                permission: "external_directory",
-                patterns: [want],
-                always: [want],
-              })
-            }),
-          ),
-        ),
-      )
-
-      it.live("uses Git Bash /tmp semantics for external file paths", () =>
-        withShell(
-          { label: "bash", shell: bash },
-          runIn(
-            projectRoot,
-            Effect.gen(function* () {
-              const err = new Error("stop after permission")
-              const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-              const want = glob(path.join(os.tmpdir(), "*"))
-              expect(
-                yield* fail(
-                  {
-                    command: "cat /tmp/miaw-does-not-exist",
-                    description: "Read Git Bash tmp file",
-                  },
-                  capture(requests, err),
-                ),
-              ).toMatchObject({ message: err.message })
-              expect(requests[0]).toMatchObject({
-                permission: "external_directory",
-                patterns: [want],
-                always: [want],
-              })
-            }),
-          ),
-        ),
-      )
-    }
-  }
-
-  each("asks for external_directory permission when file arg is outside project", () =>
-    Effect.gen(function* () {
-      const outerTmp = yield* tmpdirScoped()
-      yield* Effect.promise(() => Bun.write(path.join(outerTmp, "outside.txt"), "x"))
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const err = new Error("stop after permission")
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          const filepath = path.join(outerTmp, "outside.txt")
-          expect(
-            yield* fail(
-              {
-                command: `cat ${filepath}`,
-                description: "Read external file",
-              },
-              capture(requests, err),
-            ),
-          ).toMatchObject({ message: err.message })
-          const extDirReq = requests.find((r) => r.permission === "external_directory")
-          const expected = glob(path.join(outerTmp, "*"))
-          expect(extDirReq).toBeDefined()
-          expect(extDirReq!.patterns).toContain(expected)
-          expect(extDirReq!.always).toContain(expected)
-          expect(extDirReq!.metadata).toMatchObject({
-            command: `cat ${filepath}`,
-            description: "Read external file",
-            directories: [outerTmp],
-            patterns: [expected],
-          })
-        }),
-      )
-    }),
-  )
-
-  each("does not ask for external_directory permission when rm inside project", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* Effect.promise(() => Bun.write(path.join(tmp, "tmpfile"), "x"))
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          yield* run(
-            {
-              command: `rm -rf ${path.join(tmp, "nested")}`,
-              description: "Remove nested dir",
-            },
-            capture(requests),
-          )
-          const extDirReq = requests.find((r) => r.permission === "external_directory")
-          expect(extDirReq).toBeUndefined()
-        }),
-      )
-    }),
-  )
-
-  each("includes always patterns for auto-approval", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          yield* run(
-            {
-              command: "git log --oneline -5",
-              description: "Git log",
-            },
-            capture(requests),
-          )
-          expect(requests.length).toBe(1)
-          expect(requests[0].always.length).toBeGreaterThan(0)
-          expect(requests[0].always.some((item) => item.endsWith("*"))).toBe(true)
-        }),
-      )
-    }),
-  )
-
-  each("does not ask for bash permission when command is cd only", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          yield* run(
-            {
-              command: "cd .",
-              description: "Stay in current directory",
-            },
-            capture(requests),
-          )
-          const bashReq = requests.find((r) => r.permission === "bash")
-          expect(bashReq).toBeUndefined()
-        }),
-      )
-    }),
-  )
-
-  each("matches redirects in permission pattern", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const err = new Error("stop after permission")
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          expect(
-            yield* fail(
-              { command: "echo test > output.txt", description: "Redirect test output" },
-              capture(requests, err),
-            ),
-          ).toMatchObject({ message: err.message })
-          const bashReq = requests.find((r) => r.permission === "bash")
-          expect(bashReq).toBeDefined()
-          expect(bashReq!.patterns).toContain("echo test > output.txt")
-        }),
-      )
-    }),
-  )
-
-  each("always pattern has space before wildcard to not include different commands", () =>
-    Effect.gen(function* () {
-      const tmp = yield* tmpdirScoped()
-      yield* runIn(
-        tmp,
-        Effect.gen(function* () {
-          const requests: Array<Omit<PermissionV1.Request, "id" | "sessionID" | "tool">> = []
-          yield* run({ command: "ls -la", description: "List" }, capture(requests))
-          const bashReq = requests.find((r) => r.permission === "bash")
-          expect(bashReq).toBeDefined()
-          expect(bashReq!.always[0]).toBe("ls *")
-        }),
-      )
-    }),
-  )
-})
-
-describe("tool.shell abort", () => {
-  it.live(
-    "preserves output when aborted",
-    () =>
-      runIn(
-        projectRoot,
-        Effect.gen(function* () {
-          const controller = new AbortController()
-          const collected: string[] = []
-          const res = yield* run(
-            {
-              command: `echo before && sleep 30`,
-              description: "Long running command",
-            },
-            {
-              ...ctx,
-              abort: controller.signal,
-              metadata: (input) =>
-                Effect.sync(() => {
-                  const output = (input.metadata as { output?: string })?.output
-                  if (output && output.includes("before") && !controller.signal.aborted) {
-                    collected.push(output)
-                    controller.abort()
-                  }
-                }),
-            },
-          )
-          expect(res.output).toContain("before")
-          expect(res.output).toContain("User aborted the command")
-          expect(collected.length).toBeGreaterThan(0)
-        }),
-      ),
-    15_000,
-  )
-
-  it.live(
-    "terminates command on timeout",
-    () =>
-      runIn(
-        projectRoot,
-        Effect.gen(function* () {
-          const result = yield* run({
-            command: `sleep 60`,
-            description: "Timeout test",
-            timeout: 500,
-          })
-          expect(result.output).toContain("shell tool terminated command after exceeding timeout")
-          expect(result.output).toContain("retry with a larger timeout value in milliseconds")
-        }),
-      ),
-    15_000,
-  )
-
-  it.live(
-    "uses RuntimeFlags bashDefaultTimeoutMs when timeout is omitted",
-    () =>
-      runIn(
-        projectRoot,
-        Effect.gen(function* () {
-          const tool = yield* initShell()
-          expect(tool.description).toContain("commands will time out after 500ms")
-          const result = yield* tool.execute(
-            {
-              command: `sleep 60`,
-              description: "Default timeout test",
-            },
-            ctx,
-          )
-          expect(result.output).toContain("exceeding timeout 500 ms")
-        }),
-      ).pipe(Effect.provide(RuntimeFlags.layer({ bashDefaultTimeoutMs: 500 }))),
-    15_000,
-  )
-
-  if (process.platform !== "win32") {
-    it.live("captures stderr in output", () =>
-      runIn(
-        projectRoot,
-        Effect.gen(function* () {
-          const result = yield* run({
-            command: `echo stdout_msg && echo stderr_msg >&2`,
-            description: "Stderr test",
-          })
-          expect(result.output).toContain("stdout_msg")
-          expect(result.output).toContain("stderr_msg")
-          expect(result.metadata.exit).toBe(0)
-        }),
-      ),
-    )
-  }
-
-  it.live("returns non-zero exit code", () =>
-    runIn(
-      projectRoot,
-      Effect.gen(function* () {
-        const result = yield* run({
-          command: `exit 42`,
-          description: "Non-zero exit",
-        })
-        expect(result.metadata.exit).toBe(42)
-      }),
-    ),
-  )
-
-  it.live("streams metadata updates progressively", () =>
-    runIn(
-      projectRoot,
-      Effect.gen(function* () {
-        const updates: string[] = []
-        const result = yield* run(
-          {
-            command: `echo first && sleep 0.1 && echo second`,
-            description: "Streaming test",
-          },
-          {
-            ...ctx,
-            metadata: (input) =>
-              Effect.sync(() => {
-                const output = (input.metadata as { output?: string })?.output
-                if (output) updates.push(output)
-              }),
-          },
-        )
-        expect(result.output).toContain("first")
-        expect(result.output).toContain("second")
-        expect(updates.length).toBeGreaterThan(1)
-      }),
-    ),
-  )
-})
-
-describe("tool.shell truncation", () => {
-  it.live("truncates output exceeding line limit", () =>
-    runIn(
-      projectRoot,
-      Effect.gen(function* () {
-        const lineCount = Truncate.MAX_LINES + 500
-        const result = yield* run({
-          command: fill("lines", lineCount),
-          description: "Generate lines exceeding limit",
-        })
-        mustTruncate(result)
-        expect(result.output).toMatch(/\.\.\.output truncated\.\.\./)
-        expect(result.output).toMatch(/Full output saved to:\s+\S+/)
-      }),
-    ),
-  )
-
-  it.live("truncates output exceeding byte limit", () =>
-    runIn(
-      projectRoot,
-      Effect.gen(function* () {
-        const byteCount = Truncate.MAX_BYTES + 10000
-        const result = yield* run({
-          command: fill("bytes", byteCount),
-          description: "Generate bytes exceeding limit",
-        })
-        mustTruncate(result)
-        expect(result.output).toMatch(/\.\.\.output truncated\.\.\./)
-        expect(result.output).toMatch(/Full output saved to:\s+\S+/)
-      }),
-    ),
-  )
-
-  it.live("does not truncate small output", () =>
-    runIn(
-      projectRoot,
-      Effect.gen(function* () {
-        const result = yield* run({
-          command: fill("lines", 1),
-          description: "Generate one line",
-        })
-        expect((result.metadata as { truncated?: boolean }).truncated).toBe(false)
-        expect(result.output).toContain("1")
-      }),
-    ),
-  )
-
-  it.live("full output is saved to file when truncated", () =>
-    runIn(
-      projectRoot,
-      Effect.gen(function* () {
-        const lineCount = Truncate.MAX_LINES + 100
-        const result = yield* run({
-          command: fill("lines", lineCount),
-          description: "Generate lines for file check",
-        })
-        mustTruncate(result)
-
-        const filepath = (result.metadata as { outputPath?: string }).outputPath
-        expect(filepath).toBeTruthy()
-
-        const saved = yield* (yield* FSUtil.Service).readFileString(filepath!)
-        const lines = saved.trim().split(/\r?\n/)
-        expect(lines.length).toBe(lineCount)
-        expect(lines[0]).toBe("1")
-        expect(lines[lineCount - 1]).toBe(String(lineCount))
-      }),
-    ),
-  )
-})