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 "../../src/shell/shell" import { ShellTool } from "../../src/tool/shell" import { Filesystem } from "@/util/filesystem" import { provideInstance, 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 "@opencode-ai/core/cross-spawn-spawner" import { AppFileSystem } from "@opencode-ai/core/filesystem" import { Plugin } from "../../src/plugin" import { testEffect } from "../lib/effect" import { Tool } from "@/tool/tool" import { RuntimeFlags } from "@/effect/runtime-flags" const shellLayer = Layer.mergeAll( CrossSpawnSpawner.defaultLayer, AppFileSystem.defaultLayer, Plugin.defaultLayer, Truncate.defaultLayer, Config.defaultLayer, Agent.defaultLayer, RuntimeFlags.defaultLayer, ) const it = testEffect(shellLayer) type ShellTestServices = | (typeof shellLayer extends Layer.Layer ? ROut : never) | 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, next: Tool.Context = ctx, ) { const bash = yield* initShell() return yield* bash.execute(args, next) }) const runIn = (directory: string, self: Effect.Effect) => self.pipe(provideInstance(directory)) const fail = Effect.fn("ShellToolTest.fail")(function* ( args: Tool.InferParameters, 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 = (item: { label: string; shell: string }, self: Effect.Effect) => 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, ) => { for (const item of shells) { it.live(`${name} [${item.label}]`, () => withShell(item, fn(item))) } } const capture = (requests: Array>, stop?: Error) => ({ ...ctx, ask: (req: Omit) => Effect.sync(() => { requests.push(req) if (stop) throw stop }), }) const mustTruncate = (result: { metadata: { truncated?: boolean; exit?: number | null } & Record 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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 = "OPENCODE_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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] const want = glob(path.join(os.tmpdir(), "*")) expect( yield* fail( { command: "cat /tmp/opencode-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> = [] 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) }), ) }), ) 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> = [] 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> = [] 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> = [] 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> = [] 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> = [] 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: `echo started && sleep 60`, description: "Timeout test", timeout: 500, }) expect(result.output).toContain("started") 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: `echo started && sleep 60`, description: "Default timeout test", }, ctx, ) expect(result.output).toContain("started") 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* AppFileSystem.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)) }), ), ) })