Fixes #1070: Rename internal bash tool to terminal for cross-platform accuracy

Author: ainaanraza

packages/core/src/tool/builtins.ts

@@ -1,7 +1,7 @@
 export * as BuiltInTools from "./builtins"
 
 import { Layer } from "effect"
-import { BashTool } from "./bash"
+import { TerminalTool } from "./terminal"
 import { ApplyPatchTool } from "./apply-patch"
 import { EditTool } from "./edit"
 import { GlobTool } from "./glob"
@@ -30,7 +30,7 @@ import { WriteTool } from "./write"
  */
 export const locationLayer = Layer.mergeAll(
   ApplyPatchTool.layer,
-  BashTool.layer,
+  TerminalTool.layer,
   EditTool.layer,
   GlobTool.layer,
   GrepTool.layer,

packages/core/src/tool/bash.ts packages/core/src/tool/terminal.tspackages/core/src/tool/bash.ts renamed to packages/core/src/tool/terminal.ts

@@ -1,4 +1,4 @@
-export * as BashTool from "./bash"
+export * as TerminalTool from "./terminal"
 
 import path from "path"
 import { ToolFailure } from "@opencode-ai/llm"
@@ -13,7 +13,7 @@ import { PositiveInt } from "../schema"
 import { Tool } from "./tool"
 import { Tools } from "./tools"
 
-export const name = "bash"
+export const name = "terminal"
 export const DEFAULT_TIMEOUT_MS = 2 * 60 * 1_000
 export const MAX_TIMEOUT_MS = 10 * 60 * 1_000
 export const MAX_CAPTURE_BYTES = 1024 * 1024

packages/core/src/v1/config/permission.ts

@@ -21,7 +21,8 @@ const InputObject = Schema.StructWithRest(
     glob: Schema.optional(Rule),
     grep: Schema.optional(Rule),
     list: Schema.optional(Rule),
-    bash: Schema.optional(Rule),
+    bash: Schema.optional(Rule), // kept for backward compatibility but mapped to "terminal"
+    terminal: Schema.optional(Rule),
     task: Schema.optional(Rule),
     external_directory: Schema.optional(Rule),
     todowrite: Schema.optional(Action),
@@ -37,8 +38,14 @@ const InputObject = Schema.StructWithRest(
 
 const InputSchema = Schema.Union([Action, InputObject])
 
-const normalizeInput = (input: Schema.Schema.Type<typeof InputSchema>): Schema.Schema.Type<typeof InputObject> =>
-  typeof input === "string" ? { "*": input } : input
+const normalizeInput = (input: Schema.Schema.Type<typeof InputSchema>): Schema.Schema.Type<typeof InputObject> => {
+  if (typeof input === "string") return { "*": input }
+  const result = { ...input }
+  if (result.terminal !== undefined && result.bash !== undefined) {
+    delete (result as any).bash
+  }
+  return result
+}
 
 export const Info = InputSchema.pipe(
   Schema.decodeTo(InputObject, {

packages/core/test/config/agent.test.ts

@@ -81,8 +81,8 @@ describe("ConfigAgentPlugin.Plugin", () => {
         { action: "read", resource: "*", effect: "allow" },
         { action: "bash", resource: "git *", effect: "allow" },
       ])
-      expect(PermissionV2.evaluate("bash", "git status", buildAgent.permissions).effect).toBe("allow")
-      expect(PermissionV2.evaluate("bash", "bun test", buildAgent.permissions).effect).toBe("ask")
+      expect(PermissionV2.evaluate("terminal", "git status", buildAgent.permissions).effect).toBe("allow")
+      expect(PermissionV2.evaluate("terminal", "bun test", buildAgent.permissions).effect).toBe("ask")
 
       const reviewer = yield* agents.get(AgentV2.ID.make("reviewer"))
       if (!reviewer) throw new Error("expected configured reviewer agent")

packages/core/test/session-runner-tool-registry.test.ts

@@ -66,8 +66,7 @@ describe("ToolRegistry", () => {
       const names = (rules: Parameters<ToolRegistry.Interface["materialize"]>[0]) =>
         toolDefinitions(service, rules).pipe(Effect.map((definitions) => definitions.map((tool) => tool.name)))
 
-      expect(yield* names([{ action: "question", resource: "*", effect: "deny" }])).toEqual([
-        "bash",
+      expect(yield* names([{ action: "question", resource: "*", effect: "deny" }])).toEqual(["terminal",
         "edit",
         "write",
         "apply_patch",
@@ -84,7 +83,7 @@ describe("ToolRegistry", () => {
           { action: "*", resource: "*", effect: "deny" },
         ]),
       ).toEqual([])
-      expect(yield* names([{ action: "edit", resource: "*", effect: "deny" }])).toEqual(["question", "bash"])
+      expect(yield* names([{ action: "edit", resource: "*", effect: "deny" }])).toEqual(["question", "terminal"])
     }),
   )
 

packages/core/test/session-tool-progress.test.ts

@@ -74,14 +74,14 @@ describe("Tool.Progress", () => {
             timestamp,
             assistantMessageID,
             callID,
-            name: "bash",
+            name: "terminal",
           })
           yield* service.publish(SessionEvent.Tool.Called, {
             sessionID,
             timestamp,
             assistantMessageID,
             callID,
-            tool: "bash",
+            tool: "terminal",
             input: { command: "pwd" },
             provider: { executed: false },
           })

packages/core/test/tool-bash.test.ts packages/core/test/tool-terminal.test.tspackages/core/test/tool-bash.test.ts renamed to packages/core/test/tool-terminal.test.ts

@@ -12,7 +12,7 @@ import { PermissionV2 } from "@opencode-ai/core/permission"
 import { AppProcess } from "@opencode-ai/core/process"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
-import { BashTool } from "@opencode-ai/core/tool/bash"
+import { TerminalTool } from "@opencode-ai/core/tool/terminal"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
@@ -102,7 +102,7 @@ const withTool = <A, E, R>(
   )
   const mutation = LocationMutation.layer.pipe(Layer.provide(filesystem), Layer.provide(activeLocation))
   const registry = ToolRegistry.defaultLayer.pipe(Layer.provide(permission))
-  const bash = BashTool.layer.pipe(
+  const bash = TerminalTool.layer.pipe(
     Layer.provide(registry),
     Layer.provide(permission),
     Layer.provide(mutation),
@@ -115,15 +115,15 @@ const withTool = <A, E, R>(
   }).pipe(Effect.provide(Layer.mergeAll(registry, bash)))
 }
 
-const call = (input: typeof BashTool.Input.Type, id = "call-bash") => ({
+const call = (input: typeof TerminalTool.Input.Type, id = "call-bash") => ({
   sessionID,
   ...toolIdentity,
-  call: { type: "tool-call" as const, id, name: "bash", input },
+  call: { type: "tool-call" as const, id, name: "terminal", input },
 })
 
 const it = testEffect(Layer.empty)
 
-describe("BashTool", () => {
+describe("TerminalTool", () => {
   it.live("registers and returns structured successful output from the active Location", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),
@@ -132,9 +132,9 @@ describe("BashTool", () => {
         return withTool(tmp.path, (registry) =>
           Effect.gen(function* () {
             const definitions = yield* toolDefinitions(registry)
-            expect(definitions.map((tool) => tool.name)).toEqual(["bash"])
+            expect(definitions.map((tool) => tool.name)).toEqual(["terminal"])
             expect(definitions[0]?.inputSchema).not.toHaveProperty("properties.background")
-            expect(yield* toolDefinitions(registry, [{ action: "bash", resource: "*", effect: "deny" }])).toEqual([])
+            expect(yield* toolDefinitions(registry, [{ action: "terminal", resource: "*", effect: "deny" }])).toEqual([])
             expect(
               yield* settleTool(registry, call({ command: "pwd", description: "Print working directory" })),
             ).toEqual({
@@ -152,10 +152,10 @@ describe("BashTool", () => {
             })
             expect(runs).toMatchObject([{ command: "pwd", cwd: realpathSync(tmp.path) }])
             expect(runs[0]?.options).toMatchObject({
-              maxOutputBytes: BashTool.MAX_CAPTURE_BYTES,
-              maxErrorBytes: BashTool.MAX_CAPTURE_BYTES,
+              maxOutputBytes: TerminalTool.MAX_CAPTURE_BYTES,
+              maxErrorBytes: TerminalTool.MAX_CAPTURE_BYTES,
             })
-            expect(assertions).toMatchObject([{ sessionID, action: "bash", resources: ["pwd"], save: ["pwd"] }])
+            expect(assertions).toMatchObject([{ sessionID, action: "terminal", resources: ["pwd"], save: ["pwd"] }])
           }),
         )
       },
@@ -188,7 +188,7 @@ describe("BashTool", () => {
         reset()
         const workdir = path.join(tmp.path, "src")
         afterPermission = (input) =>
-          input.action === "bash"
+          input.action === "terminal"
             ? Effect.promise(async () => {
                 await fs.rm(workdir, { recursive: true })
                 await fs.writeFile(workdir, "not a directory")
@@ -201,7 +201,7 @@ describe("BashTool", () => {
           Effect.andThen(
             Effect.sync(() => {
               expect(runs).toEqual([])
-              expect(assertions.map((input) => input.action)).toEqual(["bash"])
+              expect(assertions.map((input) => input.action)).toEqual(["terminal"])
             }),
           ),
         )
@@ -249,7 +249,7 @@ describe("BashTool", () => {
         ).pipe(
           Effect.andThen(
             Effect.sync(() => {
-              expect(assertions.map((item) => item.action)).toEqual(["external_directory", "bash"])
+              expect(assertions.map((item) => item.action)).toEqual(["external_directory", "terminal"])
               expect(assertions[0]).toMatchObject({
                 resources: [path.join(realpathSync(outside.path), "*").replaceAll("\\", "/")],
               })
@@ -281,7 +281,7 @@ describe("BashTool", () => {
           reset()
           denyAction = "bash"
           yield* withTool(active.path, (registry) => executeTool(registry, call({ command: "pwd" })))
-          expect(assertions.map((item) => item.action)).toEqual(["bash"])
+          expect(assertions.map((item) => item.action)).toEqual(["terminal"])
           expect(runs).toEqual([])
         }),
       ([active, outside]) =>
@@ -301,7 +301,7 @@ describe("BashTool", () => {
         return withTool(active.path, (registry) => settleTool(registry, call({ command: `cat ${target}` }))).pipe(
           Effect.andThen((settled) =>
             Effect.sync(() => {
-              expect(assertions.map((item) => item.action)).toEqual(["bash"])
+              expect(assertions.map((item) => item.action)).toEqual(["terminal"])
               expect(runs).toHaveLength(1)
               expect(settled.output?.structured).toMatchObject({
                 warnings: [
@@ -399,7 +399,7 @@ describe("BashTool", () => {
 })
 
 test("keeps locked deferred parity TODOs visible", async () => {
-  const source = await fs.readFile(new URL("../src/tool/bash.ts", import.meta.url), "utf8")
+  const source = await fs.readFile(new URL("../src/tool/terminal.ts", import.meta.url), "utf8")
   for (const todo of [
     "Port tree-sitter bash / PowerShell parser-based approval reduction.",
     "Port BashArity reusable command-prefix approvals.",

packages/opencode/specs/v2/api.ts

@@ -8,7 +8,7 @@ const opencode = OpenCode.make({})
 opencode.tool.add(ReadTool)
 
 opencode.tool.add({
-  name: "bash",
+  name: "terminal",
   schema: {
     type: "object",
     properties: {

packages/opencode/src/acp/event.ts

@@ -281,7 +281,7 @@ export class Subscription {
   private async runningTool(sessionId: string, part: ToolPart, cwd: string) {
     if (part.state.status !== "running") return
 
-    const output = part.tool === "bash" ? shellOutputSnapshot(part.state) : undefined
+    const output = part.tool === "terminal" ? shellOutputSnapshot(part.state) : undefined
     if (output !== undefined) {
       if (this.shellSnapshots.get(part.callID) === output) {
         await this.input.connection.sessionUpdate({

packages/opencode/src/acp/tool.ts

@@ -296,7 +296,7 @@ function shellCommand(input: ToolInput) {
 
 function isShell(toolName: string) {
   const tool = toolName.toLocaleLowerCase()
-  return tool === "bash" || tool === "shell"
+  return tool === "terminal" || tool === "shell"
 }
 
 export const mapToolKind = toToolKind