next.test.ts 38 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170
  1. import { test, expect } from "bun:test"
  2. import os from "os"
  3. import { Cause, Deferred, Effect, Exit, Fiber, Layer } from "effect"
  4. import { EventV2Bridge } from "../../src/event-v2-bridge"
  5. import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
  6. import { Database } from "@opencode-ai/core/database/database"
  7. import { Permission } from "../../src/permission"
  8. import { PermissionID } from "../../src/permission/schema"
  9. import { InstanceBootstrap } from "../../src/project/bootstrap-service"
  10. import { InstanceStore } from "../../src/project/instance-store"
  11. import { TestInstance, tmpdirScoped } from "../fixture/fixture"
  12. import { testEffect } from "../lib/effect"
  13. import { MessageID, SessionID } from "../../src/session/schema"
  14. const events = EventV2Bridge.defaultLayer
  15. const noopBootstrap = Layer.succeed(InstanceBootstrap.Service, InstanceBootstrap.Service.of({ run: Effect.void }))
  16. const env = Layer.mergeAll(
  17. Permission.layer.pipe(Layer.provide(Database.defaultLayer), Layer.provide(events)),
  18. events,
  19. CrossSpawnSpawner.defaultLayer,
  20. InstanceStore.defaultLayer.pipe(Layer.provide(noopBootstrap)),
  21. )
  22. const it = testEffect(env)
  23. const rejectAll = (message?: string) =>
  24. Effect.gen(function* () {
  25. const permission = yield* Permission.Service
  26. for (const req of yield* permission.list()) {
  27. yield* permission.reply({
  28. requestID: req.id,
  29. reply: "reject",
  30. message,
  31. })
  32. }
  33. })
  34. const waitForPending = (count: number) =>
  35. Effect.gen(function* () {
  36. const permission = yield* Permission.Service
  37. return yield* Effect.gen(function* () {
  38. while (true) {
  39. const list = yield* permission.list()
  40. if (list.length === count) return list
  41. yield* Effect.sleep("10 millis")
  42. }
  43. }).pipe(
  44. Effect.timeoutOrElse({
  45. duration: "1 second",
  46. orElse: () => Effect.fail(new Error(`timed out waiting for ${count} pending permission request(s)`)),
  47. }),
  48. )
  49. })
  50. const fail = <A, E, R>(self: Effect.Effect<A, E, R>) =>
  51. Effect.gen(function* () {
  52. const exit = yield* self.pipe(Effect.exit)
  53. if (Exit.isFailure(exit)) return Cause.squash(exit.cause)
  54. throw new Error("expected permission effect to fail")
  55. })
  56. const ask = (input: Parameters<Permission.Interface["ask"]>[0]) =>
  57. Effect.gen(function* () {
  58. const permission = yield* Permission.Service
  59. return yield* permission.ask(input)
  60. })
  61. const reply = (input: Parameters<Permission.Interface["reply"]>[0]) =>
  62. Effect.gen(function* () {
  63. const permission = yield* Permission.Service
  64. return yield* permission.reply(input)
  65. })
  66. const list = () =>
  67. Effect.gen(function* () {
  68. const permission = yield* Permission.Service
  69. return yield* permission.list()
  70. })
  71. // fromConfig tests
  72. test("fromConfig - string value becomes wildcard rule", () => {
  73. const result = Permission.fromConfig({ bash: "allow" })
  74. expect(result).toEqual([{ permission: "bash", pattern: "*", action: "allow" }])
  75. })
  76. test("fromConfig - object value converts to rules array", () => {
  77. const result = Permission.fromConfig({ bash: { "*": "allow", rm: "deny" } })
  78. expect(result).toEqual([
  79. { permission: "bash", pattern: "*", action: "allow" },
  80. { permission: "bash", pattern: "rm", action: "deny" },
  81. ])
  82. })
  83. test("fromConfig - mixed string and object values", () => {
  84. const result = Permission.fromConfig({
  85. bash: { "*": "allow", rm: "deny" },
  86. edit: "allow",
  87. webfetch: "ask",
  88. })
  89. expect(result).toEqual([
  90. { permission: "bash", pattern: "*", action: "allow" },
  91. { permission: "bash", pattern: "rm", action: "deny" },
  92. { permission: "edit", pattern: "*", action: "allow" },
  93. { permission: "webfetch", pattern: "*", action: "ask" },
  94. ])
  95. })
  96. test("fromConfig - empty object", () => {
  97. const result = Permission.fromConfig({})
  98. expect(result).toEqual([])
  99. })
  100. test("fromConfig - expands tilde to home directory", () => {
  101. const result = Permission.fromConfig({ external_directory: { "~/projects/*": "allow" } })
  102. expect(result).toEqual([{ permission: "external_directory", pattern: `${os.homedir()}/projects/*`, action: "allow" }])
  103. })
  104. test("fromConfig - expands $HOME to home directory", () => {
  105. const result = Permission.fromConfig({ external_directory: { "$HOME/projects/*": "allow" } })
  106. expect(result).toEqual([{ permission: "external_directory", pattern: `${os.homedir()}/projects/*`, action: "allow" }])
  107. })
  108. test("fromConfig - expands $HOME without trailing slash", () => {
  109. const result = Permission.fromConfig({ external_directory: { $HOME: "allow" } })
  110. expect(result).toEqual([{ permission: "external_directory", pattern: os.homedir(), action: "allow" }])
  111. })
  112. test("fromConfig - does not expand tilde in middle of path", () => {
  113. const result = Permission.fromConfig({ external_directory: { "/some/~/path": "allow" } })
  114. expect(result).toEqual([{ permission: "external_directory", pattern: "/some/~/path", action: "allow" }])
  115. })
  116. // Permission precedence follows config insertion order. `evaluate()` uses the
  117. // last matching rule, so later config entries intentionally override earlier
  118. // entries even when a wildcard appears after a specific permission.
  119. test("fromConfig - preserves top-level config key order", () => {
  120. const wildcardFirst = Permission.fromConfig({ "*": "deny", bash: "allow" })
  121. const specificFirst = Permission.fromConfig({ bash: "allow", "*": "deny" })
  122. expect(wildcardFirst.map((r) => r.permission)).toEqual(["*", "bash"])
  123. expect(specificFirst.map((r) => r.permission)).toEqual(["bash", "*"])
  124. expect(Permission.evaluate("bash", "ls", wildcardFirst).action).toBe("allow")
  125. expect(Permission.evaluate("bash", "ls", specificFirst).action).toBe("deny")
  126. })
  127. test("fromConfig - wildcard acts as fallback when it appears before specifics", () => {
  128. const ruleset = Permission.fromConfig({ "*": "ask", bash: "allow" })
  129. expect(Permission.evaluate("edit", "foo.ts", ruleset).action).toBe("ask")
  130. expect(Permission.evaluate("bash", "ls", ruleset).action).toBe("allow")
  131. })
  132. test("fromConfig - top-level ordering is not sorted by wildcard specificity", () => {
  133. const ruleset = Permission.fromConfig({
  134. bash: "allow",
  135. "*": "ask",
  136. edit: "deny",
  137. "mcp_*": "allow",
  138. })
  139. expect(ruleset.map((r) => r.permission)).toEqual(["bash", "*", "edit", "mcp_*"])
  140. })
  141. test("fromConfig - sub-pattern insertion order inside a tool key is preserved", () => {
  142. const ruleset = Permission.fromConfig({ bash: { "*": "deny", "git *": "allow" } })
  143. expect(ruleset.map((r) => r.pattern)).toEqual(["*", "git *"])
  144. expect(Permission.evaluate("bash", "rm foo", ruleset).action).toBe("deny")
  145. expect(Permission.evaluate("bash", "git status", ruleset).action).toBe("allow")
  146. })
  147. test("fromConfig - documented fallback-first example", () => {
  148. const ruleset = Permission.fromConfig({ "*": "ask", bash: "allow", edit: "deny" })
  149. expect(Permission.evaluate("bash", "ls", ruleset).action).toBe("allow")
  150. expect(Permission.evaluate("edit", "foo.ts", ruleset).action).toBe("deny")
  151. expect(Permission.evaluate("read", "foo.ts", ruleset).action).toBe("ask")
  152. })
  153. test("fromConfig - expands exact tilde to home directory", () => {
  154. const result = Permission.fromConfig({ external_directory: { "~": "allow" } })
  155. expect(result).toEqual([{ permission: "external_directory", pattern: os.homedir(), action: "allow" }])
  156. })
  157. test("evaluate - matches expanded tilde pattern", () => {
  158. const ruleset = Permission.fromConfig({ external_directory: { "~/projects/*": "allow" } })
  159. const result = Permission.evaluate("external_directory", `${os.homedir()}/projects/file.txt`, ruleset)
  160. expect(result.action).toBe("allow")
  161. })
  162. test("evaluate - matches expanded $HOME pattern", () => {
  163. const ruleset = Permission.fromConfig({ external_directory: { "$HOME/projects/*": "allow" } })
  164. const result = Permission.evaluate("external_directory", `${os.homedir()}/projects/file.txt`, ruleset)
  165. expect(result.action).toBe("allow")
  166. })
  167. // merge tests
  168. test("merge - simple concatenation", () => {
  169. const result = Permission.merge(
  170. [{ permission: "bash", pattern: "*", action: "allow" }],
  171. [{ permission: "bash", pattern: "*", action: "deny" }],
  172. )
  173. expect(result).toEqual([
  174. { permission: "bash", pattern: "*", action: "allow" },
  175. { permission: "bash", pattern: "*", action: "deny" },
  176. ])
  177. })
  178. test("merge - adds new permission", () => {
  179. const result = Permission.merge(
  180. [{ permission: "bash", pattern: "*", action: "allow" }],
  181. [{ permission: "edit", pattern: "*", action: "deny" }],
  182. )
  183. expect(result).toEqual([
  184. { permission: "bash", pattern: "*", action: "allow" },
  185. { permission: "edit", pattern: "*", action: "deny" },
  186. ])
  187. })
  188. test("merge - concatenates rules for same permission", () => {
  189. const result = Permission.merge(
  190. [{ permission: "bash", pattern: "foo", action: "ask" }],
  191. [{ permission: "bash", pattern: "*", action: "deny" }],
  192. )
  193. expect(result).toEqual([
  194. { permission: "bash", pattern: "foo", action: "ask" },
  195. { permission: "bash", pattern: "*", action: "deny" },
  196. ])
  197. })
  198. test("merge - multiple rulesets", () => {
  199. const result = Permission.merge(
  200. [{ permission: "bash", pattern: "*", action: "allow" }],
  201. [{ permission: "bash", pattern: "rm", action: "ask" }],
  202. [{ permission: "edit", pattern: "*", action: "allow" }],
  203. )
  204. expect(result).toEqual([
  205. { permission: "bash", pattern: "*", action: "allow" },
  206. { permission: "bash", pattern: "rm", action: "ask" },
  207. { permission: "edit", pattern: "*", action: "allow" },
  208. ])
  209. })
  210. test("merge - empty ruleset does nothing", () => {
  211. const result = Permission.merge([{ permission: "bash", pattern: "*", action: "allow" }], [])
  212. expect(result).toEqual([{ permission: "bash", pattern: "*", action: "allow" }])
  213. })
  214. test("merge - preserves rule order", () => {
  215. const result = Permission.merge(
  216. [
  217. { permission: "edit", pattern: "src/*", action: "allow" },
  218. { permission: "edit", pattern: "src/secret/*", action: "deny" },
  219. ],
  220. [{ permission: "edit", pattern: "src/secret/ok.ts", action: "allow" }],
  221. )
  222. expect(result).toEqual([
  223. { permission: "edit", pattern: "src/*", action: "allow" },
  224. { permission: "edit", pattern: "src/secret/*", action: "deny" },
  225. { permission: "edit", pattern: "src/secret/ok.ts", action: "allow" },
  226. ])
  227. })
  228. test("merge - config permission overrides default ask", () => {
  229. const defaults: Permission.Ruleset = [{ permission: "*", pattern: "*", action: "ask" }]
  230. const config: Permission.Ruleset = [{ permission: "bash", pattern: "*", action: "allow" }]
  231. const merged = Permission.merge(defaults, config)
  232. expect(Permission.evaluate("bash", "ls", merged).action).toBe("allow")
  233. expect(Permission.evaluate("edit", "foo.ts", merged).action).toBe("ask")
  234. })
  235. test("merge - config ask overrides default allow", () => {
  236. const defaults: Permission.Ruleset = [{ permission: "bash", pattern: "*", action: "allow" }]
  237. const config: Permission.Ruleset = [{ permission: "bash", pattern: "*", action: "ask" }]
  238. const merged = Permission.merge(defaults, config)
  239. expect(Permission.evaluate("bash", "ls", merged).action).toBe("ask")
  240. })
  241. // evaluate tests
  242. test("evaluate - exact pattern match", () => {
  243. const result = Permission.evaluate("bash", "rm", [{ permission: "bash", pattern: "rm", action: "deny" }])
  244. expect(result.action).toBe("deny")
  245. })
  246. test("evaluate - wildcard pattern match", () => {
  247. const result = Permission.evaluate("bash", "rm", [{ permission: "bash", pattern: "*", action: "allow" }])
  248. expect(result.action).toBe("allow")
  249. })
  250. test("evaluate - last matching rule wins", () => {
  251. const result = Permission.evaluate("bash", "rm", [
  252. { permission: "bash", pattern: "*", action: "allow" },
  253. { permission: "bash", pattern: "rm", action: "deny" },
  254. ])
  255. expect(result.action).toBe("deny")
  256. })
  257. test("evaluate - last matching rule wins (wildcard after specific)", () => {
  258. const result = Permission.evaluate("bash", "rm", [
  259. { permission: "bash", pattern: "rm", action: "deny" },
  260. { permission: "bash", pattern: "*", action: "allow" },
  261. ])
  262. expect(result.action).toBe("allow")
  263. })
  264. test("evaluate - glob pattern match", () => {
  265. const result = Permission.evaluate("edit", "src/foo.ts", [{ permission: "edit", pattern: "src/*", action: "allow" }])
  266. expect(result.action).toBe("allow")
  267. })
  268. test("evaluate - last matching glob wins", () => {
  269. const result = Permission.evaluate("edit", "src/components/Button.tsx", [
  270. { permission: "edit", pattern: "src/*", action: "deny" },
  271. { permission: "edit", pattern: "src/components/*", action: "allow" },
  272. ])
  273. expect(result.action).toBe("allow")
  274. })
  275. test("evaluate - order matters for specificity", () => {
  276. const result = Permission.evaluate("edit", "src/components/Button.tsx", [
  277. { permission: "edit", pattern: "src/components/*", action: "allow" },
  278. { permission: "edit", pattern: "src/*", action: "deny" },
  279. ])
  280. expect(result.action).toBe("deny")
  281. })
  282. test("evaluate - unknown permission returns ask", () => {
  283. const result = Permission.evaluate("unknown_tool", "anything", [
  284. { permission: "bash", pattern: "*", action: "allow" },
  285. ])
  286. expect(result.action).toBe("ask")
  287. })
  288. test("evaluate - empty ruleset returns ask", () => {
  289. const result = Permission.evaluate("bash", "rm", [])
  290. expect(result.action).toBe("ask")
  291. })
  292. test("evaluate - no matching pattern returns ask", () => {
  293. const result = Permission.evaluate("edit", "etc/passwd", [{ permission: "edit", pattern: "src/*", action: "allow" }])
  294. expect(result.action).toBe("ask")
  295. })
  296. test("evaluate - empty rules array returns ask", () => {
  297. const result = Permission.evaluate("bash", "rm", [])
  298. expect(result.action).toBe("ask")
  299. })
  300. test("evaluate - multiple matching patterns, last wins", () => {
  301. const result = Permission.evaluate("edit", "src/secret.ts", [
  302. { permission: "edit", pattern: "*", action: "ask" },
  303. { permission: "edit", pattern: "src/*", action: "allow" },
  304. { permission: "edit", pattern: "src/secret.ts", action: "deny" },
  305. ])
  306. expect(result.action).toBe("deny")
  307. })
  308. test("evaluate - non-matching patterns are skipped", () => {
  309. const result = Permission.evaluate("edit", "src/foo.ts", [
  310. { permission: "edit", pattern: "*", action: "ask" },
  311. { permission: "edit", pattern: "test/*", action: "deny" },
  312. { permission: "edit", pattern: "src/*", action: "allow" },
  313. ])
  314. expect(result.action).toBe("allow")
  315. })
  316. test("evaluate - exact match at end wins over earlier wildcard", () => {
  317. const result = Permission.evaluate("bash", "/bin/rm", [
  318. { permission: "bash", pattern: "*", action: "allow" },
  319. { permission: "bash", pattern: "/bin/rm", action: "deny" },
  320. ])
  321. expect(result.action).toBe("deny")
  322. })
  323. test("evaluate - wildcard at end overrides earlier exact match", () => {
  324. const result = Permission.evaluate("bash", "/bin/rm", [
  325. { permission: "bash", pattern: "/bin/rm", action: "deny" },
  326. { permission: "bash", pattern: "*", action: "allow" },
  327. ])
  328. expect(result.action).toBe("allow")
  329. })
  330. // wildcard permission tests
  331. test("evaluate - wildcard permission matches any permission", () => {
  332. const result = Permission.evaluate("bash", "rm", [{ permission: "*", pattern: "*", action: "deny" }])
  333. expect(result.action).toBe("deny")
  334. })
  335. test("evaluate - wildcard permission with specific pattern", () => {
  336. const result = Permission.evaluate("bash", "rm", [{ permission: "*", pattern: "rm", action: "deny" }])
  337. expect(result.action).toBe("deny")
  338. })
  339. test("evaluate - glob permission pattern", () => {
  340. const result = Permission.evaluate("mcp_server_tool", "anything", [
  341. { permission: "mcp_*", pattern: "*", action: "allow" },
  342. ])
  343. expect(result.action).toBe("allow")
  344. })
  345. test("evaluate - specific permission and wildcard permission combined", () => {
  346. const result = Permission.evaluate("bash", "rm", [
  347. { permission: "*", pattern: "*", action: "deny" },
  348. { permission: "bash", pattern: "*", action: "allow" },
  349. ])
  350. expect(result.action).toBe("allow")
  351. })
  352. test("evaluate - wildcard permission does not match when specific exists", () => {
  353. const result = Permission.evaluate("edit", "src/foo.ts", [
  354. { permission: "*", pattern: "*", action: "deny" },
  355. { permission: "edit", pattern: "src/*", action: "allow" },
  356. ])
  357. expect(result.action).toBe("allow")
  358. })
  359. test("evaluate - multiple matching permission patterns combine rules", () => {
  360. const result = Permission.evaluate("mcp_dangerous", "anything", [
  361. { permission: "*", pattern: "*", action: "ask" },
  362. { permission: "mcp_*", pattern: "*", action: "allow" },
  363. { permission: "mcp_dangerous", pattern: "*", action: "deny" },
  364. ])
  365. expect(result.action).toBe("deny")
  366. })
  367. test("evaluate - wildcard permission fallback for unknown tool", () => {
  368. const result = Permission.evaluate("unknown_tool", "anything", [
  369. { permission: "*", pattern: "*", action: "ask" },
  370. { permission: "bash", pattern: "*", action: "allow" },
  371. ])
  372. expect(result.action).toBe("ask")
  373. })
  374. test("evaluate - later wildcard permission can override earlier specific permission", () => {
  375. const result = Permission.evaluate("bash", "rm", [
  376. { permission: "bash", pattern: "*", action: "allow" },
  377. { permission: "*", pattern: "*", action: "deny" },
  378. ])
  379. expect(result.action).toBe("deny")
  380. })
  381. test("evaluate - merges multiple rulesets", () => {
  382. const config: Permission.Ruleset = [{ permission: "bash", pattern: "*", action: "allow" }]
  383. const approved: Permission.Ruleset = [{ permission: "bash", pattern: "rm", action: "deny" }]
  384. const result = Permission.evaluate("bash", "rm", config, approved)
  385. expect(result.action).toBe("deny")
  386. })
  387. // disabled tests
  388. test("disabled - returns empty set when all tools allowed", () => {
  389. const result = Permission.disabled(["bash", "edit", "read"], [{ permission: "*", pattern: "*", action: "allow" }])
  390. expect(result.size).toBe(0)
  391. })
  392. test("disabled - disables tool when denied", () => {
  393. const result = Permission.disabled(
  394. ["bash", "edit", "read"],
  395. [
  396. { permission: "*", pattern: "*", action: "allow" },
  397. { permission: "bash", pattern: "*", action: "deny" },
  398. ],
  399. )
  400. expect(result.has("bash")).toBe(true)
  401. expect(result.has("edit")).toBe(false)
  402. expect(result.has("read")).toBe(false)
  403. })
  404. test("disabled - disables edit/write/apply_patch when edit denied", () => {
  405. const result = Permission.disabled(
  406. ["edit", "write", "apply_patch", "bash"],
  407. [
  408. { permission: "*", pattern: "*", action: "allow" },
  409. { permission: "edit", pattern: "*", action: "deny" },
  410. ],
  411. )
  412. expect(result.has("edit")).toBe(true)
  413. expect(result.has("write")).toBe(true)
  414. expect(result.has("apply_patch")).toBe(true)
  415. expect(result.has("bash")).toBe(false)
  416. })
  417. test("disabled - does not disable when partially denied", () => {
  418. const result = Permission.disabled(
  419. ["bash"],
  420. [
  421. { permission: "bash", pattern: "*", action: "allow" },
  422. { permission: "bash", pattern: "rm *", action: "deny" },
  423. ],
  424. )
  425. expect(result.has("bash")).toBe(false)
  426. })
  427. test("disabled - does not disable when action is ask", () => {
  428. const result = Permission.disabled(["bash", "edit"], [{ permission: "*", pattern: "*", action: "ask" }])
  429. expect(result.size).toBe(0)
  430. })
  431. test("disabled - does not disable when specific allow after wildcard deny", () => {
  432. const result = Permission.disabled(
  433. ["bash"],
  434. [
  435. { permission: "bash", pattern: "*", action: "deny" },
  436. { permission: "bash", pattern: "echo *", action: "allow" },
  437. ],
  438. )
  439. expect(result.has("bash")).toBe(false)
  440. })
  441. test("disabled - does not disable when wildcard allow after deny", () => {
  442. const result = Permission.disabled(
  443. ["bash"],
  444. [
  445. { permission: "bash", pattern: "rm *", action: "deny" },
  446. { permission: "bash", pattern: "*", action: "allow" },
  447. ],
  448. )
  449. expect(result.has("bash")).toBe(false)
  450. })
  451. test("disabled - disables multiple tools", () => {
  452. const result = Permission.disabled(
  453. ["bash", "edit", "webfetch"],
  454. [
  455. { permission: "bash", pattern: "*", action: "deny" },
  456. { permission: "edit", pattern: "*", action: "deny" },
  457. { permission: "webfetch", pattern: "*", action: "deny" },
  458. ],
  459. )
  460. expect(result.has("bash")).toBe(true)
  461. expect(result.has("edit")).toBe(true)
  462. expect(result.has("webfetch")).toBe(true)
  463. })
  464. test("disabled - wildcard permission denies all tools", () => {
  465. const result = Permission.disabled(["bash", "edit", "read"], [{ permission: "*", pattern: "*", action: "deny" }])
  466. expect(result.has("bash")).toBe(true)
  467. expect(result.has("edit")).toBe(true)
  468. expect(result.has("read")).toBe(true)
  469. })
  470. test("disabled - specific allow overrides wildcard deny", () => {
  471. const result = Permission.disabled(
  472. ["bash", "edit", "read"],
  473. [
  474. { permission: "*", pattern: "*", action: "deny" },
  475. { permission: "bash", pattern: "*", action: "allow" },
  476. ],
  477. )
  478. expect(result.has("bash")).toBe(false)
  479. expect(result.has("edit")).toBe(true)
  480. expect(result.has("read")).toBe(true)
  481. })
  482. // ask tests
  483. it.instance(
  484. "ask - resolves immediately when action is allow",
  485. () =>
  486. Effect.gen(function* () {
  487. const result = yield* ask({
  488. sessionID: SessionID.make("session_test"),
  489. permission: "bash",
  490. patterns: ["ls"],
  491. metadata: {},
  492. always: [],
  493. ruleset: [{ permission: "bash", pattern: "*", action: "allow" }],
  494. })
  495. expect(result).toBeUndefined()
  496. }),
  497. { git: true },
  498. )
  499. it.instance(
  500. "ask - throws DeniedError when action is deny",
  501. () =>
  502. Effect.gen(function* () {
  503. const err = yield* fail(
  504. ask({
  505. sessionID: SessionID.make("session_test"),
  506. permission: "bash",
  507. patterns: ["rm -rf /"],
  508. metadata: {},
  509. always: [],
  510. ruleset: [{ permission: "bash", pattern: "*", action: "deny" }],
  511. }),
  512. )
  513. expect(err).toBeInstanceOf(Permission.DeniedError)
  514. }),
  515. { git: true },
  516. )
  517. it.instance(
  518. "ask - stays pending when action is ask",
  519. () =>
  520. Effect.gen(function* () {
  521. const fiber = yield* ask({
  522. sessionID: SessionID.make("session_test"),
  523. permission: "bash",
  524. patterns: ["ls"],
  525. metadata: {},
  526. always: [],
  527. ruleset: [{ permission: "bash", pattern: "*", action: "ask" }],
  528. }).pipe(Effect.forkScoped)
  529. expect(yield* waitForPending(1)).toHaveLength(1)
  530. yield* rejectAll()
  531. yield* Fiber.await(fiber)
  532. }),
  533. { git: true },
  534. )
  535. it.instance(
  536. "ask - adds request to pending list",
  537. () =>
  538. Effect.gen(function* () {
  539. const fiber = yield* ask({
  540. sessionID: SessionID.make("session_test"),
  541. permission: "bash",
  542. patterns: ["ls"],
  543. metadata: { cmd: "ls" },
  544. always: ["ls"],
  545. tool: {
  546. messageID: MessageID.make("msg_test"),
  547. callID: "call_test",
  548. },
  549. ruleset: [],
  550. }).pipe(Effect.forkScoped)
  551. const items = yield* waitForPending(1)
  552. expect(items).toHaveLength(1)
  553. expect(items[0]).toMatchObject({
  554. sessionID: SessionID.make("session_test"),
  555. permission: "bash",
  556. patterns: ["ls"],
  557. metadata: { cmd: "ls" },
  558. always: ["ls"],
  559. tool: {
  560. messageID: MessageID.make("msg_test"),
  561. callID: "call_test",
  562. },
  563. })
  564. yield* rejectAll()
  565. yield* Fiber.await(fiber)
  566. }),
  567. { git: true },
  568. )
  569. it.instance(
  570. "ask - publishes asked event",
  571. () =>
  572. Effect.gen(function* () {
  573. const events = yield* EventV2Bridge.Service
  574. const seen = yield* Deferred.make<Permission.Request>()
  575. const unsub = yield* events.listen((event) => {
  576. if (event.type === Permission.Event.Asked.type)
  577. Deferred.doneUnsafe(seen, Effect.succeed(event.data as Permission.Request))
  578. return Effect.void
  579. })
  580. yield* Effect.addFinalizer(() => unsub)
  581. const fiber = yield* ask({
  582. sessionID: SessionID.make("session_test"),
  583. permission: "bash",
  584. patterns: ["ls"],
  585. metadata: { cmd: "ls" },
  586. always: ["ls"],
  587. tool: {
  588. messageID: MessageID.make("msg_test"),
  589. callID: "call_test",
  590. },
  591. ruleset: [],
  592. }).pipe(Effect.forkScoped)
  593. expect(yield* waitForPending(1)).toHaveLength(1)
  594. expect(
  595. yield* Deferred.await(seen).pipe(
  596. Effect.timeoutOrElse({
  597. duration: "1 second",
  598. orElse: () => Effect.fail(new Error("timed out waiting for permission asked event")),
  599. }),
  600. ),
  601. ).toMatchObject({
  602. sessionID: SessionID.make("session_test"),
  603. permission: "bash",
  604. patterns: ["ls"],
  605. })
  606. yield* rejectAll()
  607. yield* Fiber.await(fiber)
  608. }),
  609. { git: true },
  610. )
  611. // reply tests
  612. it.instance(
  613. "reply - once resolves the pending ask",
  614. () =>
  615. Effect.gen(function* () {
  616. const fiber = yield* ask({
  617. id: PermissionID.make("per_test1"),
  618. sessionID: SessionID.make("session_test"),
  619. permission: "bash",
  620. patterns: ["ls"],
  621. metadata: {},
  622. always: [],
  623. ruleset: [],
  624. }).pipe(Effect.forkScoped)
  625. yield* waitForPending(1)
  626. yield* reply({ requestID: PermissionID.make("per_test1"), reply: "once" })
  627. yield* Fiber.join(fiber)
  628. }),
  629. { git: true },
  630. )
  631. it.instance(
  632. "reply - reject throws RejectedError",
  633. () =>
  634. Effect.gen(function* () {
  635. const fiber = yield* ask({
  636. id: PermissionID.make("per_test2"),
  637. sessionID: SessionID.make("session_test"),
  638. permission: "bash",
  639. patterns: ["ls"],
  640. metadata: {},
  641. always: [],
  642. ruleset: [],
  643. }).pipe(Effect.forkScoped)
  644. yield* waitForPending(1)
  645. yield* reply({ requestID: PermissionID.make("per_test2"), reply: "reject" })
  646. const exit = yield* Fiber.await(fiber)
  647. expect(Exit.isFailure(exit)).toBe(true)
  648. if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Permission.RejectedError)
  649. }),
  650. { git: true },
  651. )
  652. it.instance(
  653. "reply - reject with message throws CorrectedError",
  654. () =>
  655. Effect.gen(function* () {
  656. const fiber = yield* ask({
  657. id: PermissionID.make("per_test2b"),
  658. sessionID: SessionID.make("session_test"),
  659. permission: "bash",
  660. patterns: ["ls"],
  661. metadata: {},
  662. always: [],
  663. ruleset: [],
  664. }).pipe(Effect.forkScoped)
  665. yield* waitForPending(1)
  666. yield* reply({
  667. requestID: PermissionID.make("per_test2b"),
  668. reply: "reject",
  669. message: "Use a safer command",
  670. })
  671. const exit = yield* Fiber.await(fiber)
  672. expect(Exit.isFailure(exit)).toBe(true)
  673. if (Exit.isFailure(exit)) {
  674. const err = Cause.squash(exit.cause)
  675. expect(err).toBeInstanceOf(Permission.CorrectedError)
  676. expect(String(err)).toContain("Use a safer command")
  677. }
  678. }),
  679. { git: true },
  680. )
  681. it.instance(
  682. "reply - always persists approval and resolves",
  683. () =>
  684. Effect.gen(function* () {
  685. const fiber = yield* ask({
  686. id: PermissionID.make("per_test3"),
  687. sessionID: SessionID.make("session_test"),
  688. permission: "bash",
  689. patterns: ["ls"],
  690. metadata: {},
  691. always: ["ls"],
  692. ruleset: [],
  693. }).pipe(Effect.forkScoped)
  694. yield* waitForPending(1)
  695. yield* reply({ requestID: PermissionID.make("per_test3"), reply: "always" })
  696. yield* Fiber.join(fiber)
  697. const result = yield* ask({
  698. sessionID: SessionID.make("session_test2"),
  699. permission: "bash",
  700. patterns: ["ls"],
  701. metadata: {},
  702. always: [],
  703. ruleset: [],
  704. })
  705. expect(result).toBeUndefined()
  706. }),
  707. { git: true },
  708. )
  709. it.instance(
  710. "reply - reject cancels all pending for same session",
  711. () =>
  712. Effect.gen(function* () {
  713. const a = yield* ask({
  714. id: PermissionID.make("per_test4a"),
  715. sessionID: SessionID.make("session_same"),
  716. permission: "bash",
  717. patterns: ["ls"],
  718. metadata: {},
  719. always: [],
  720. ruleset: [],
  721. }).pipe(Effect.forkScoped)
  722. const b = yield* ask({
  723. id: PermissionID.make("per_test4b"),
  724. sessionID: SessionID.make("session_same"),
  725. permission: "edit",
  726. patterns: ["foo.ts"],
  727. metadata: {},
  728. always: [],
  729. ruleset: [],
  730. }).pipe(Effect.forkScoped)
  731. yield* waitForPending(2)
  732. yield* reply({ requestID: PermissionID.make("per_test4a"), reply: "reject" })
  733. const [ea, eb] = yield* Effect.all([Fiber.await(a), Fiber.await(b)])
  734. expect(Exit.isFailure(ea)).toBe(true)
  735. expect(Exit.isFailure(eb)).toBe(true)
  736. if (Exit.isFailure(ea)) expect(Cause.squash(ea.cause)).toBeInstanceOf(Permission.RejectedError)
  737. if (Exit.isFailure(eb)) expect(Cause.squash(eb.cause)).toBeInstanceOf(Permission.RejectedError)
  738. }),
  739. { git: true },
  740. )
  741. it.instance(
  742. "reply - always resolves matching pending requests in same session",
  743. () =>
  744. Effect.gen(function* () {
  745. const a = yield* ask({
  746. id: PermissionID.make("per_test5a"),
  747. sessionID: SessionID.make("session_same"),
  748. permission: "bash",
  749. patterns: ["ls"],
  750. metadata: {},
  751. always: ["ls"],
  752. ruleset: [],
  753. }).pipe(Effect.forkScoped)
  754. const b = yield* ask({
  755. id: PermissionID.make("per_test5b"),
  756. sessionID: SessionID.make("session_same"),
  757. permission: "bash",
  758. patterns: ["ls"],
  759. metadata: {},
  760. always: [],
  761. ruleset: [],
  762. }).pipe(Effect.forkScoped)
  763. yield* waitForPending(2)
  764. yield* reply({ requestID: PermissionID.make("per_test5a"), reply: "always" })
  765. yield* Fiber.join(a)
  766. yield* Fiber.join(b)
  767. expect(yield* list()).toHaveLength(0)
  768. }),
  769. { git: true },
  770. )
  771. it.instance(
  772. "reply - always keeps other session pending",
  773. () =>
  774. Effect.gen(function* () {
  775. const a = yield* ask({
  776. id: PermissionID.make("per_test6a"),
  777. sessionID: SessionID.make("session_a"),
  778. permission: "bash",
  779. patterns: ["ls"],
  780. metadata: {},
  781. always: ["ls"],
  782. ruleset: [],
  783. }).pipe(Effect.forkScoped)
  784. const b = yield* ask({
  785. id: PermissionID.make("per_test6b"),
  786. sessionID: SessionID.make("session_b"),
  787. permission: "bash",
  788. patterns: ["ls"],
  789. metadata: {},
  790. always: [],
  791. ruleset: [],
  792. }).pipe(Effect.forkScoped)
  793. yield* waitForPending(2)
  794. yield* reply({ requestID: PermissionID.make("per_test6a"), reply: "always" })
  795. yield* Fiber.join(a)
  796. expect((yield* list()).map((item) => item.id)).toEqual([PermissionID.make("per_test6b")])
  797. yield* rejectAll()
  798. yield* Fiber.await(b)
  799. }),
  800. { git: true },
  801. )
  802. it.instance(
  803. "reply - publishes replied event",
  804. () =>
  805. Effect.gen(function* () {
  806. const events = yield* EventV2Bridge.Service
  807. const seen = yield* Deferred.make<{ sessionID: SessionID; requestID: PermissionID; reply: Permission.Reply }>()
  808. const fiber = yield* ask({
  809. id: PermissionID.make("per_test7"),
  810. sessionID: SessionID.make("session_test"),
  811. permission: "bash",
  812. patterns: ["ls"],
  813. metadata: {},
  814. always: [],
  815. ruleset: [],
  816. }).pipe(Effect.forkScoped)
  817. yield* waitForPending(1)
  818. const unsub = yield* events.listen((event) => {
  819. if (event.type === Permission.Event.Replied.type)
  820. Deferred.doneUnsafe(
  821. seen,
  822. Effect.succeed(event.data as { sessionID: SessionID; requestID: PermissionID; reply: Permission.Reply }),
  823. )
  824. return Effect.void
  825. })
  826. yield* Effect.addFinalizer(() => unsub)
  827. yield* reply({ requestID: PermissionID.make("per_test7"), reply: "once" })
  828. yield* Fiber.join(fiber)
  829. expect(
  830. yield* Deferred.await(seen).pipe(
  831. Effect.timeoutOrElse({
  832. duration: "1 second",
  833. orElse: () => Effect.fail(new Error("timed out waiting for permission replied event")),
  834. }),
  835. ),
  836. ).toEqual({
  837. sessionID: SessionID.make("session_test"),
  838. requestID: PermissionID.make("per_test7"),
  839. reply: "once",
  840. })
  841. }),
  842. { git: true },
  843. )
  844. it.live("permission requests stay isolated by directory", () =>
  845. Effect.gen(function* () {
  846. const one = yield* tmpdirScoped({ git: true })
  847. const two = yield* tmpdirScoped({ git: true })
  848. const store = yield* InstanceStore.Service
  849. const a = yield* store
  850. .provide(
  851. { directory: one },
  852. ask({
  853. id: PermissionID.make("per_dir_a"),
  854. sessionID: SessionID.make("session_dir_a"),
  855. permission: "bash",
  856. patterns: ["ls"],
  857. metadata: {},
  858. always: [],
  859. ruleset: [],
  860. }),
  861. )
  862. .pipe(Effect.forkScoped)
  863. const b = yield* store
  864. .provide(
  865. { directory: two },
  866. ask({
  867. id: PermissionID.make("per_dir_b"),
  868. sessionID: SessionID.make("session_dir_b"),
  869. permission: "bash",
  870. patterns: ["pwd"],
  871. metadata: {},
  872. always: [],
  873. ruleset: [],
  874. }),
  875. )
  876. .pipe(Effect.forkScoped)
  877. const onePending = yield* store.provide({ directory: one }, waitForPending(1))
  878. const twoPending = yield* store.provide({ directory: two }, waitForPending(1))
  879. expect(onePending).toHaveLength(1)
  880. expect(twoPending).toHaveLength(1)
  881. expect(onePending[0].id).toBe(PermissionID.make("per_dir_a"))
  882. expect(twoPending[0].id).toBe(PermissionID.make("per_dir_b"))
  883. yield* store.provide({ directory: one }, reply({ requestID: onePending[0].id, reply: "reject" }))
  884. yield* store.provide({ directory: two }, reply({ requestID: twoPending[0].id, reply: "reject" }))
  885. yield* Fiber.await(a)
  886. yield* Fiber.await(b)
  887. }),
  888. )
  889. it.instance(
  890. "pending permission rejects on instance dispose",
  891. () =>
  892. Effect.gen(function* () {
  893. const test = yield* TestInstance
  894. const store = yield* InstanceStore.Service
  895. const fiber = yield* ask({
  896. id: PermissionID.make("per_dispose"),
  897. sessionID: SessionID.make("session_dispose"),
  898. permission: "bash",
  899. patterns: ["ls"],
  900. metadata: {},
  901. always: [],
  902. ruleset: [],
  903. }).pipe(Effect.forkScoped)
  904. expect(yield* waitForPending(1)).toHaveLength(1)
  905. const ctx = yield* store.load({ directory: test.directory })
  906. yield* store.dispose(ctx)
  907. const exit = yield* Fiber.await(fiber)
  908. expect(Exit.isFailure(exit)).toBe(true)
  909. if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Permission.RejectedError)
  910. }),
  911. { git: true },
  912. )
  913. it.instance(
  914. "pending permission rejects on instance reload",
  915. () =>
  916. Effect.gen(function* () {
  917. const test = yield* TestInstance
  918. const store = yield* InstanceStore.Service
  919. const fiber = yield* ask({
  920. id: PermissionID.make("per_reload"),
  921. sessionID: SessionID.make("session_reload"),
  922. permission: "bash",
  923. patterns: ["ls"],
  924. metadata: {},
  925. always: [],
  926. ruleset: [],
  927. }).pipe(Effect.forkScoped)
  928. expect(yield* waitForPending(1)).toHaveLength(1)
  929. yield* store.reload({ directory: test.directory })
  930. const exit = yield* Fiber.await(fiber)
  931. expect(Exit.isFailure(exit)).toBe(true)
  932. if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Permission.RejectedError)
  933. }),
  934. { git: true },
  935. )
  936. it.instance(
  937. "reply - fails for unknown requestID",
  938. () =>
  939. Effect.gen(function* () {
  940. const exit = yield* reply({ requestID: PermissionID.make("per_unknown"), reply: "once" }).pipe(Effect.exit)
  941. expect(Exit.isFailure(exit)).toBe(true)
  942. if (Exit.isFailure(exit)) {
  943. expect(Cause.squash(exit.cause)).toMatchObject({ _tag: "Permission.NotFoundError", requestID: "per_unknown" })
  944. }
  945. expect(yield* list()).toHaveLength(0)
  946. }),
  947. { git: true },
  948. )
  949. it.instance(
  950. "ask - checks all patterns and stops on first deny",
  951. () =>
  952. Effect.gen(function* () {
  953. const err = yield* fail(
  954. ask({
  955. sessionID: SessionID.make("session_test"),
  956. permission: "bash",
  957. patterns: ["echo hello", "rm -rf /"],
  958. metadata: {},
  959. always: [],
  960. ruleset: [
  961. { permission: "bash", pattern: "*", action: "allow" },
  962. { permission: "bash", pattern: "rm *", action: "deny" },
  963. ],
  964. }),
  965. )
  966. expect(err).toBeInstanceOf(Permission.DeniedError)
  967. }),
  968. { git: true },
  969. )
  970. it.instance(
  971. "ask - allows all patterns when all match allow rules",
  972. () =>
  973. Effect.gen(function* () {
  974. const result = yield* ask({
  975. sessionID: SessionID.make("session_test"),
  976. permission: "bash",
  977. patterns: ["echo hello", "ls -la", "pwd"],
  978. metadata: {},
  979. always: [],
  980. ruleset: [{ permission: "bash", pattern: "*", action: "allow" }],
  981. })
  982. expect(result).toBeUndefined()
  983. }),
  984. { git: true },
  985. )
  986. it.instance(
  987. "ask - should deny even when an earlier pattern is ask",
  988. () =>
  989. Effect.gen(function* () {
  990. const err = yield* fail(
  991. ask({
  992. sessionID: SessionID.make("session_test"),
  993. permission: "bash",
  994. patterns: ["echo hello", "rm -rf /"],
  995. metadata: {},
  996. always: [],
  997. ruleset: [
  998. { permission: "bash", pattern: "echo *", action: "ask" },
  999. { permission: "bash", pattern: "rm *", action: "deny" },
  1000. ],
  1001. }),
  1002. )
  1003. expect(err).toBeInstanceOf(Permission.DeniedError)
  1004. expect(yield* list()).toHaveLength(0)
  1005. }),
  1006. { git: true },
  1007. )
  1008. it.instance(
  1009. "ask - abort should clear pending request",
  1010. () =>
  1011. Effect.gen(function* () {
  1012. const test = yield* TestInstance
  1013. const store = yield* InstanceStore.Service
  1014. const fiber = yield* ask({
  1015. id: PermissionID.make("per_reload"),
  1016. sessionID: SessionID.make("session_reload"),
  1017. permission: "bash",
  1018. patterns: ["ls"],
  1019. metadata: {},
  1020. always: [],
  1021. ruleset: [{ permission: "bash", pattern: "*", action: "ask" }],
  1022. }).pipe(Effect.forkScoped)
  1023. const pending = yield* waitForPending(1)
  1024. expect(pending).toHaveLength(1)
  1025. yield* store.reload({ directory: test.directory })
  1026. const exit = yield* Fiber.await(fiber)
  1027. expect(Exit.isFailure(exit)).toBe(true)
  1028. if (Exit.isFailure(exit)) expect(Cause.squash(exit.cause)).toBeInstanceOf(Permission.RejectedError)
  1029. }),
  1030. { git: true },
  1031. )