fix

Author: e-n-0

packages/opencode/src/session/prompt.ts

@@ -36,14 +36,15 @@ import { NamedError } from "@opencode-ai/shared/util/error"
 import { SessionProcessor } from "./processor"
 import { Tool } from "@/tool"
 import { Permission } from "@/permission"
+import { Instance } from "@/project/instance"
 import { SessionStatus } from "./status"
 import { LLM } from "./llm"
 import { Shell } from "@/shell/shell"
 import { AppFileSystem } from "@opencode-ai/shared/filesystem"
 import { Truncate } from "@/tool"
 import { decodeDataUrl } from "@/util/data-url"
 import { Process } from "@/util"
-import { Cause, Effect, Exit, Layer, Option, Scope, Context } from "effect"
+import { Cause, Effect, Exit, Fiber, Layer, Option, Scope, Context } from "effect"
 import { EffectLogger } from "@/effect"
 import { InstanceState } from "@/effect"
 import { TaskTool, type TaskPromptOps } from "@/tool/task"
@@ -816,7 +817,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
 
         return yield* Effect.gen(function* () {
           try {
-            const cfg = yield* Effect.promise(() => SandboxSpawn.settings())
+            const cfg = yield* Effect.promise(Instance.bind(() => SandboxSpawn.settings()))
             const blocked = SandboxSpawn.excludedText(input.command, cfg.excluded_commands)
             if (blocked) {
               throw new SandboxSpawn.CommandError(blocked.command, blocked.rule)
@@ -910,7 +911,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
               })
               const exit = yield* Effect.gen(function* () {
                 const handle = yield* spawner.spawn(proc)
-                yield* Effect.forkScoped(
+                const stdout = yield* Effect.forkScoped(
                   Stream.runForEach(Stream.decodeText(handle.stdout), (chunk) =>
                     Effect.sync(() => {
                       output += chunk
@@ -921,7 +922,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                     }),
                   ),
                 )
-                yield* Effect.forkScoped(
+                const err = yield* Effect.forkScoped(
                   Stream.runForEach(Stream.decodeText(handle.stderr), (chunk) =>
                     Effect.sync(() => {
                       stderr += chunk
@@ -933,7 +934,11 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                     }),
                   ),
                 )
-                return yield* handle.exitCode
+
+                const code = yield* handle.exitCode
+                yield* Fiber.await(stdout)
+                yield* Fiber.await(err)
+                return code
               }).pipe(
                 Effect.scoped,
                 Effect.onInterrupt(() =>

packages/opencode/src/tool/bash.ts

@@ -17,7 +17,7 @@ import { Shell } from "@/shell/shell"
 import { BashArity } from "@/permission/arity"
 import * as Truncate from "./truncate"
 import { Plugin } from "@/plugin"
-import { Cause, Effect, Exit, Stream } from "effect"
+import { Cause, Effect, Exit, Fiber, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
 import { SandboxSpawn } from "@/sandbox/spawn"
@@ -424,7 +424,6 @@ export const BashTool = Tool.define(
     const fs = yield* AppFileSystem.Service
     const trunc = yield* Truncate.Service
     const plugin = yield* Plugin.Service
-    const sandbox = yield* Effect.promise(() => SandboxSpawn.settings())
 
     const cygpath = Effect.fn("BashTool.cygpath")(function* (shell: string, text: string) {
       const lines = yield* spawner
@@ -610,18 +609,17 @@ export const BashTool = Tool.define(
           Effect.gen(function* () {
             const handle = yield* spawner.spawn(proc)
 
-            yield* Effect.forkScoped(
+            const out = yield* Effect.forkScoped(
               Stream.runForEach(Stream.decodeText(handle.stdout), (chunk) => {
                 return write(chunk)
               }),
             )
-            yield* Effect.forkScoped(
+            const err = yield* Effect.forkScoped(
               Stream.runForEach(Stream.decodeText(handle.stderr), (chunk) => {
                 stderr += chunk
                 return write(chunk)
               }),
             )
-
             const abort = Effect.callback<void>((resume) => {
               if (ctx.abort.aborted) return resume(Effect.void)
               const handler = () => resume(Effect.void)
@@ -646,6 +644,9 @@ export const BashTool = Tool.define(
               yield* handle.kill({ forceKillAfter: "3 seconds" }).pipe(Effect.orDie)
             }
 
+            yield* Fiber.await(out)
+            yield* Fiber.await(err)
+
             return exit.kind === "exit" ? exit.code : null
           }),
         ).pipe(Effect.orDie)
@@ -794,24 +795,26 @@ export const BashTool = Tool.define(
       Effect.sync(() => {
         const shell = Shell.acceptable()
         const name = Shell.name(shell)
+        let dir = process.cwd()
+        try {
+          dir = Instance.directory
+        } catch {}
         const chain =
           name === "powershell"
             ? "If the commands depend on each other and must run sequentially, avoid '&&' in this shell because Windows PowerShell 5.1 does not support it. Use PowerShell conditionals such as `cmd1; if ($?) { cmd2 }` when later commands must depend on earlier success."
             : "If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them together (e.g., `git add . && git commit -m \"message\" && git push`). For instance, if one operation must complete before another starts (like mkdir before cp, Write before Bash for git operations, or git add before git commit), run these operations sequentially instead."
         log.info("bash tool using shell", { shell })
 
         return {
-          description: DESCRIPTION.replaceAll("${directory}", Instance.directory)
+          description: DESCRIPTION.replaceAll("${directory}", dir)
             .replaceAll("${os}", process.platform)
             .replaceAll("${shell}", name)
             .replaceAll("${chaining}", chain)
             .replaceAll("${maxLines}", String(Truncate.MAX_LINES))
             .replaceAll("${maxBytes}", String(Truncate.MAX_BYTES))
             .replaceAll(
               "${unsandboxed}",
-              sandbox.allow_unsandboxed_retry
-                ? "\n\nIf you know a command needs to run outside the sandbox before the first attempt, put `# opencode:unsandboxed <reason>` on the first non-empty line of the command. This asks for the separate `bash:unsandboxed` permission before execution while keeping the normal bash tool schema unchanged."
-                : "",
+              "\n\nIf sandbox settings allow unsandboxed retries and you know a command needs to run outside the sandbox before the first attempt, put `# opencode:unsandboxed <reason>` on the first non-empty line of the command. This asks for the separate `bash:unsandboxed` permission before execution while keeping the normal bash tool schema unchanged.",
             ),
           parameters: Parameters,
           execute: (params: z.infer<typeof Parameters>, ctx: Tool.Context) =>
@@ -825,7 +828,7 @@ export const BashTool = Tool.define(
                 throw new Error(`Invalid timeout value: ${params.timeout}. Timeout must be a positive number.`)
               }
               const timeout = params.timeout ?? DEFAULT_TIMEOUT
-              const cfg = yield* Effect.promise(() => SandboxSpawn.settings())
+              const cfg = yield* Effect.promise(Instance.bind(() => SandboxSpawn.settings()))
               const ps = PS.has(name)
               const root = yield* parse(command, ps)
               const scan = yield* collect(root, cwd, ps, shell, cfg.excluded_commands)