Skip to content

Commit 640118b

Browse files
committed
fix(opencode): match absolute permission patterns outside the worktree
Includes: - fix(opencode): match absolute permission patterns outside worktree - test(opencode): drop duplicate PermissionV1 import in apply_patch tests - test(opencode): cover absolute permission rules in a project with no VCS
1 parent 7cb044e commit 640118b

8 files changed

Lines changed: 232 additions & 5 deletions

File tree

‎packages/opencode/src/project/instance-context.ts‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
import { LocalContext } from "@/util/local-context"
2+
import path from "path"
23
import { FSUtil } from "@opencode-ai/core/fs-util"
34
import type * as Project from "./project"
45

@@ -22,3 +23,9 @@ export function containsPath(filepath: string, ctx: InstanceContext): boolean {
2223
if (ctx.worktree === "/") return false
2324
return FSUtil.contains(ctx.worktree, filepath)
2425
}
26+
27+
export function permissionPath(filepath: string, ctx: InstanceContext): string {
28+
// A root worktree is the non-git sentinel, not a project boundary.
29+
if (ctx.worktree === "/" || !containsPath(filepath, ctx)) return filepath
30+
return path.relative(ctx.worktree, filepath)
31+
}

‎packages/opencode/src/tool/apply_patch.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ import * as Tool from "./tool"
44
import { EventV2Bridge } from "@/event-v2-bridge"
55
import { Watcher } from "@opencode-ai/core/filesystem/watcher"
66
import { InstanceState } from "@/effect/instance-state"
7+
import { permissionPath } from "@/project/instance-context"
78
import { Patch } from "../patch"
89
import { createTwoFilesPatch, diffLines } from "diff"
910
import { assertExternalDirectoryEffect } from "./external-directory"
@@ -202,7 +203,7 @@ export const ApplyPatchTool = Tool.define(
202203
}))
203204

204205
// Check permissions if needed
205-
const relativePaths = fileChanges.map((c) => path.relative(instance.worktree, c.filePath).replaceAll("\\", "/"))
206+
const relativePaths = fileChanges.map((c) => permissionPath(c.filePath, instance).replaceAll("\\", "/"))
206207
yield* ctx.ask({
207208
permission: "edit",
208209
patterns: relativePaths,

‎packages/opencode/src/tool/edit.ts‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@ import { Watcher } from "@opencode-ai/core/filesystem/watcher"
1414
import { EventV2Bridge } from "@/event-v2-bridge"
1515
import { Format } from "../format"
1616
import { InstanceState } from "@/effect/instance-state"
17+
import { permissionPath } from "@/project/instance-context"
1718
import { Snapshot } from "@/snapshot"
1819
import { assertExternalDirectoryEffect } from "./external-directory"
1920
import { FSUtil } from "@opencode-ai/core/fs-util"
@@ -101,7 +102,7 @@ export const EditTool = Tool.define(
101102
diff = trimDiff(createTwoFilesPatch(filePath, filePath, contentOld, contentNew))
102103
yield* ctx.ask({
103104
permission: "edit",
104-
patterns: [path.relative(instance.worktree, filePath)],
105+
patterns: [permissionPath(filePath, instance)],
105106
always: ["*"],
106107
metadata: {
107108
filepath: filePath,
@@ -144,7 +145,7 @@ export const EditTool = Tool.define(
144145
)
145146
yield* ctx.ask({
146147
permission: "edit",
147-
patterns: [path.relative(instance.worktree, filePath)],
148+
patterns: [permissionPath(filePath, instance)],
148149
always: ["*"],
149150
metadata: {
150151
filepath: filePath,

‎packages/opencode/src/tool/read.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@ import { FSUtil } from "@opencode-ai/core/fs-util"
66
import { LSP } from "@/lsp/lsp"
77
import DESCRIPTION from "./read.txt"
88
import { InstanceState } from "@/effect/instance-state"
9+
import { permissionPath } from "@/project/instance-context"
910
import { assertExternalDirectoryEffect } from "./external-directory"
1011
import { Instruction } from "../session/instruction"
1112
import { isPdfAttachment, sniffAttachmentMime } from "@/util/media"
@@ -254,7 +255,7 @@ export const ReadTool = Tool.define<
254255

255256
yield* ctx.ask({
256257
permission: "read",
257-
patterns: [path.relative(instance.worktree, filepath)],
258+
patterns: [permissionPath(filepath, instance)],
258259
always: ["*"],
259260
metadata: {},
260261
})

‎packages/opencode/src/tool/write.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ import { Watcher } from "@opencode-ai/core/filesystem/watcher"
1111
import { Format } from "../format"
1212
import { FSUtil } from "@opencode-ai/core/fs-util"
1313
import { InstanceState } from "@/effect/instance-state"
14+
import { permissionPath } from "@/project/instance-context"
1415
import { trimDiff } from "./edit"
1516
import { assertExternalDirectoryEffect } from "./external-directory"
1617
import * as Bom from "@/util/bom"
@@ -53,7 +54,7 @@ export const WriteTool = Tool.define(
5354
const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, contentNew))
5455
yield* ctx.ask({
5556
permission: "edit",
56-
patterns: [path.relative(instance.worktree, filepath)],
57+
patterns: [permissionPath(filepath, instance)],
5758
always: ["*"],
5859
metadata: {
5960
filepath,

‎packages/opencode/test/tool/apply_patch.test.ts‎

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ import { EventV2Bridge } from "../../src/event-v2-bridge"
1313
import { Truncate } from "@/tool/truncate"
1414
import { TestInstance } from "../fixture/fixture"
1515
import { SessionID, MessageID } from "../../src/session/schema"
16+
import { Permission } from "../../src/permission"
1617
import { testEffect } from "../lib/effect"
1718

1819
const it = testEffect(
@@ -73,6 +74,24 @@ const makeCtx = () => {
7374
return { ctx, calls }
7475
}
7576

77+
const makeRulesCtx = (ruleset: PermissionV1.Ruleset) => {
78+
const calls: AskInput[] = []
79+
const ctx: ToolCtx = {
80+
...baseCtx,
81+
ask: (input) =>
82+
Effect.sync(() => {
83+
calls.push(input)
84+
if (input.permission === "external_directory") return
85+
for (const pattern of input.patterns) {
86+
const rule = Permission.evaluate(input.permission, pattern, ruleset)
87+
if (rule.action !== "allow") throw new Error(`permission ${rule.action}: ${pattern}`)
88+
}
89+
}),
90+
}
91+
92+
return { ctx, calls }
93+
}
94+
7695
const readText = (filepath: string) => Effect.promise(() => fs.readFile(filepath, "utf-8"))
7796
const writeText = (filepath: string, content: string) => Effect.promise(() => fs.writeFile(filepath, content, "utf-8"))
7897
const makeDir = (dir: string) => Effect.promise(() => fs.mkdir(dir, { recursive: true }))
@@ -86,6 +105,33 @@ const expectFailure = <A, E, R>(effect: Effect.Effect<A, E, R>, message?: string
86105

87106
const expectReadFailure = (filepath: string) => expectFailure(readText(filepath))
88107

108+
describe("tool.apply_patch permission paths", () => {
109+
it.instance(
110+
"checks absolute rules for every outside path in a multi-file patch",
111+
() =>
112+
Effect.gen(function* () {
113+
const test = yield* TestInstance
114+
const outer = yield* Effect.promise(() =>
115+
fs.mkdtemp(path.join(path.dirname(test.directory), "opencode-outside-")),
116+
)
117+
const first = path.join(outer, "first.txt")
118+
const second = path.join(outer, "second.txt")
119+
const firstRelative = path.relative(test.directory, first).replaceAll("\\", "/")
120+
const secondRelative = path.relative(test.directory, second).replaceAll("\\", "/")
121+
const patchText = `*** Begin Patch\n*** Add File: ${firstRelative}\n+first\n*** Add File: ${secondRelative}\n+second\n*** End Patch`
122+
const { ctx, calls } = makeRulesCtx(Permission.fromConfig({ edit: { "*": "allow", [`${outer}/**`]: "deny" } }))
123+
124+
const exit = yield* execute({ patchText }, ctx).pipe(Effect.exit)
125+
expect(exit._tag).toBe("Failure")
126+
expect(calls.at(-1)?.patterns).toEqual([first, second].map((file) => file.replaceAll("\\", "/")))
127+
expect(yield* Effect.promise(() => fs.stat(first).catch(() => undefined))).toBeUndefined()
128+
expect(yield* Effect.promise(() => fs.stat(second).catch(() => undefined))).toBeUndefined()
129+
yield* Effect.promise(() => fs.rm(outer, { recursive: true, force: true }))
130+
}),
131+
{ git: true },
132+
)
133+
})
134+
89135
describe("tool.apply_patch freeform", () => {
90136
it.live("requires patchText", () =>
91137
Effect.gen(function* () {

‎packages/opencode/test/tool/read.test.ts‎

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,8 @@ import { afterEach, describe, expect } from "bun:test"
33
import { LayerNode } from "@opencode-ai/core/effect/layer-node"
44
import { Cause, Effect, Exit, Layer, Stream } from "effect"
55
import path from "path"
6+
import os from "os"
7+
import * as fs from "fs/promises"
68
import { Agent } from "../../src/agent/agent"
79
import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
810
import { FSUtil } from "@opencode-ai/core/fs-util"
@@ -148,6 +150,54 @@ const asks = () => {
148150
}
149151
}
150152

153+
const askWithRules = (ruleset: PermissionV1.Ruleset) => ({
154+
...ctx,
155+
ask: (input: Omit<PermissionV1.Request, "id" | "sessionID" | "tool">) =>
156+
Effect.sync(() => {
157+
if (input.permission === "external_directory") return
158+
for (const pattern of input.patterns) {
159+
const rule = Permission.evaluate(input.permission, pattern, ruleset)
160+
if (rule.action !== "allow") throw new Error(`permission ${rule.action}: ${pattern}`)
161+
}
162+
}),
163+
})
164+
165+
describe("tool.read permission paths", () => {
166+
it.live("allows an outside-worktree absolute rule", () =>
167+
Effect.gen(function* () {
168+
const outer = yield* tmpdirScoped()
169+
const dir = yield* tmpdirScoped({ git: true })
170+
const filepath = path.join(outer, "allowed.txt")
171+
yield* put(filepath, "allowed")
172+
173+
const result = yield* exec(
174+
dir,
175+
{ filePath: filepath },
176+
askWithRules(Permission.fromConfig({ read: { [`${outer}/**`]: "allow" } })),
177+
)
178+
expect(result.output).toContain("allowed")
179+
}),
180+
)
181+
182+
it.live("expands a tilde rule for an outside-worktree home path", () =>
183+
Effect.gen(function* () {
184+
const outer = yield* Effect.promise(() => fs.mkdtemp(path.join(os.homedir(), "opencode-permission-")))
185+
const dir = yield* tmpdirScoped({ git: true })
186+
const filepath = path.join(outer, "home-file.txt")
187+
yield* put(filepath, "home content")
188+
189+
const rule = `~/${path.relative(os.homedir(), outer).replaceAll("\\", "/")}/**`
190+
const result = yield* exec(
191+
dir,
192+
{ filePath: filepath },
193+
askWithRules(Permission.fromConfig({ read: { [rule]: "allow" } })),
194+
)
195+
expect(result.output).toContain("home content")
196+
yield* Effect.promise(() => fs.rm(outer, { recursive: true, force: true }))
197+
}),
198+
)
199+
})
200+
151201
describe("tool.read external_directory permission", () => {
152202
it.live("allows reading absolute path inside project directory", () =>
153203
Effect.gen(function* () {

‎packages/opencode/test/tool/write.test.ts‎

Lines changed: 120 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,9 @@ import { Truncate } from "@/tool/truncate"
1212
import { Tool } from "@/tool/tool"
1313
import { Agent } from "../../src/agent/agent"
1414
import { SessionID, MessageID } from "../../src/session/schema"
15+
import { PermissionV1 } from "@opencode-ai/core/v1/permission"
16+
import { Permission } from "../../src/permission"
17+
import { InstanceRef } from "../../src/effect/instance-ref"
1518
import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
1619
import { disposeAllInstances, TestInstance } from "../fixture/fixture"
1720
import { testEffect } from "../lib/effect"
@@ -58,6 +61,123 @@ const run = Effect.fn("WriteToolTest.run")(function* (
5861
return yield* tool.execute(args, next)
5962
})
6063

64+
const askWithRules = (ruleset: PermissionV1.Ruleset) => ({
65+
...ctx,
66+
ask: (input: Parameters<Tool.Context["ask"]>[0]) =>
67+
Effect.sync(() => {
68+
if (input.permission === "external_directory") return
69+
for (const pattern of input.patterns) {
70+
const rule = Permission.evaluate(input.permission, pattern, ruleset)
71+
if (rule.action !== "allow") throw new Error(`permission ${rule.action}: ${pattern}`)
72+
}
73+
}),
74+
})
75+
76+
describe("tool.write permission paths", () => {
77+
it.instance(
78+
"matches an inside-worktree relative rule",
79+
() =>
80+
Effect.gen(function* () {
81+
const test = yield* TestInstance
82+
const filepath = path.join(test.directory, "src", "inside.txt")
83+
yield* run(
84+
{ filePath: filepath, content: "inside" },
85+
askWithRules(Permission.fromConfig({ edit: { "src/**": "allow" } })),
86+
)
87+
expect(yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))).toBe("inside")
88+
}),
89+
{ git: true },
90+
)
91+
92+
it.instance(
93+
"allows an outside-worktree absolute rule",
94+
() =>
95+
Effect.gen(function* () {
96+
const test = yield* TestInstance
97+
const outer = yield* Effect.promise(() =>
98+
fs.mkdtemp(path.join(path.dirname(test.directory), "opencode-outside-")),
99+
)
100+
const filepath = path.join(outer, "allowed.txt")
101+
yield* run(
102+
{ filePath: filepath, content: "allowed" },
103+
askWithRules(Permission.fromConfig({ edit: { [`${outer}/**`]: "allow" } })),
104+
)
105+
expect(yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))).toBe("allowed")
106+
yield* Effect.promise(() => fs.rm(outer, { recursive: true, force: true }))
107+
}),
108+
{ git: true },
109+
)
110+
111+
it.instance(
112+
"enforces an outside-worktree absolute deny over a wildcard allow",
113+
() =>
114+
Effect.gen(function* () {
115+
const test = yield* TestInstance
116+
const outer = yield* Effect.promise(() =>
117+
fs.mkdtemp(path.join(path.dirname(test.directory), "opencode-outside-")),
118+
)
119+
const filepath = path.join(outer, "denied.txt")
120+
const rules = Permission.fromConfig({ edit: { "*": "allow", [`${outer}/**`]: "deny" } })
121+
const exit = yield* run({ filePath: filepath, content: "denied" }, askWithRules(rules)).pipe(Effect.exit)
122+
expect(exit._tag).toBe("Failure")
123+
expect(yield* Effect.promise(() => fs.stat(filepath).catch(() => undefined))).toBeUndefined()
124+
yield* Effect.promise(() => fs.rm(outer, { recursive: true, force: true }))
125+
}),
126+
{ git: true },
127+
)
128+
129+
it.instance(
130+
"enforces an absolute deny rule in a project with no VCS",
131+
() =>
132+
Effect.gen(function* () {
133+
const test = yield* TestInstance
134+
const instance = yield* InstanceRef
135+
expect(instance?.worktree).toBe("/")
136+
const filepath = path.join(test.directory, "denied.txt")
137+
const rules = Permission.fromConfig({ edit: { "*": "allow", [`${test.directory}/**`]: "deny" } })
138+
const exit = yield* run({ filePath: filepath, content: "denied" }, askWithRules(rules)).pipe(Effect.exit)
139+
expect(exit._tag).toBe("Failure")
140+
expect(yield* Effect.promise(() => fs.stat(filepath).catch(() => undefined))).toBeUndefined()
141+
}),
142+
{ git: false },
143+
)
144+
145+
it.instance(
146+
"allows an absolute rule in a project with no VCS",
147+
() =>
148+
Effect.gen(function* () {
149+
const test = yield* TestInstance
150+
const instance = yield* InstanceRef
151+
expect(instance?.worktree).toBe("/")
152+
const filepath = path.join(test.directory, "allowed.txt")
153+
yield* run(
154+
{ filePath: filepath, content: "allowed" },
155+
askWithRules(Permission.fromConfig({ edit: { [`${test.directory}/**`]: "allow" } })),
156+
)
157+
expect(yield* Effect.promise(() => fs.readFile(filepath, "utf-8"))).toBe("allowed")
158+
}),
159+
{ git: false },
160+
)
161+
162+
it.instance(
163+
"does not match an outside-worktree relative rule",
164+
() =>
165+
Effect.gen(function* () {
166+
const test = yield* TestInstance
167+
const outer = yield* Effect.promise(() =>
168+
fs.mkdtemp(path.join(path.dirname(test.directory), "opencode-outside-")),
169+
)
170+
const filepath = path.join(outer, "not-src.txt")
171+
const rules = Permission.fromConfig({ edit: { "src/**": "allow" } })
172+
const exit = yield* run({ filePath: filepath, content: "not allowed" }, askWithRules(rules)).pipe(Effect.exit)
173+
expect(exit._tag).toBe("Failure")
174+
expect(yield* Effect.promise(() => fs.stat(filepath).catch(() => undefined))).toBeUndefined()
175+
yield* Effect.promise(() => fs.rm(outer, { recursive: true, force: true }))
176+
}),
177+
{ git: true },
178+
)
179+
})
180+
61181
describe("tool.write", () => {
62182
describe("new file creation", () => {
63183
it.instance("writes content to new file", () =>

0 commit comments

Comments
 (0)