openAgent

1export * as LocationMutation from "./location-mutation"
2 
3import { makeLocationNode } from "./effect/app-node"
4import path from "path"
5import { Context, Effect, Layer, Schema } from "effect"
6import { FSUtil } from "./fs-util"
7import { Location } from "./location"
8 
9export const Kind = Schema.Literals(["file", "directory"])
10export type Kind = typeof Kind.Type
11 
12/**
13 * Mutation paths do not accept project references. Relative paths must stay
14 * inside the active Location. Absolute paths outside it require separate
15 * `external_directory` approval.
16 */
17export const ResolveInput = Schema.Struct({
18  path: Schema.String,
19  /** Selects the external approval boundary; it does not validate the target type. */
20  kind: Kind.pipe(Schema.optional),
21})
22export type ResolveInput = typeof ResolveInput.Type
23 
24export class PathError extends Schema.TaggedErrorClass<PathError>()("LocationMutation.PathError", {
25  path: Schema.String,
26  reason: Schema.Literals(["relative_escape", "location_escape", "non_directory_ancestor"]),
27}) {}
28 
29export interface ExternalDirectoryAuthorization {
30  readonly action: "external_directory"
31  /** Canonical existing directory used as the external approval boundary. */
32  readonly directory: string
33  /** `external_directory` permission resource. */
34  readonly resource: string
35  readonly save: string
36}
37 
38export const externalDirectoryPermission = (input: ExternalDirectoryAuthorization) => ({
39  action: input.action,
40  resources: [input.resource],
41  save: [input.save],
42})
43 
44export interface Target {
45  /** Canonical existing path, or missing path below a canonical directory. */
46  readonly canonical: string
47  /** Permission resource: Location-relative for internal paths, canonical for external paths. */
48  readonly resource: string
49  readonly externalDirectory?: ExternalDirectoryAuthorization
50}
51 
52export interface Interface {
53  /**
54   * Resolve a path and derive its permission resources. Relative paths must
55   * stay inside the Location. Absolute paths outside it require separate
56   * `external_directory` approval. This does not approve the mutation.
57   */
58  readonly resolve: (input: ResolveInput) => Effect.Effect<Target, PathError | FSUtil.Error>
59}
60 
61export class Service extends Context.Service<Service, Interface>()("@opencode/v2/LocationMutation") {}
62 
63interface ResolvedPath {
64  readonly canonical: string
65  readonly type?:
66    | "File"
67    | "Directory"
68    | "SymbolicLink"
69    | "BlockDevice"
70    | "CharacterDevice"
71    | "FIFO"
72    | "Socket"
73    | "Unknown"
74  readonly directory: string
75}
76 
77const slash = (value: string) => value.replaceAll("\\", "/")
78 
79const layer = Layer.effect(
80  Service,
81  Effect.gen(function* () {
82    const fs = yield* FSUtil.Service
83    const location = yield* Location.Service
84    const locationRoot = yield* fs.realPath(location.directory)
85 
86    function notFound<A>(effect: Effect.Effect<A, FSUtil.Error>) {
87      return effect.pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)))
88    }
89 
90    const resolvePath = Effect.fnUntraced(function* (absolute: string) {
91      const existing = yield* notFound(fs.realPath(absolute))
92      if (existing !== undefined) {
93        const info = yield* fs.stat(existing)
94        return {
95          canonical: existing,
96          type: info.type,
97          directory: info.type === "Directory" ? existing : path.dirname(existing),
98        } satisfies ResolvedPath
99      }
100 
101      let anchor = path.dirname(absolute)
102      while (true) {
103        const canonical = yield* notFound(fs.realPath(anchor))
104        if (canonical !== undefined) {
105          const info = yield* fs.stat(canonical)
106          if (info.type !== "Directory") {
107            return yield* new PathError({ path: absolute, reason: "non_directory_ancestor" })
108          }
109          return {
110            canonical: path.resolve(canonical, path.relative(anchor, absolute)),
111            directory: canonical,
112          } satisfies ResolvedPath
113        }
114        const parent = path.dirname(anchor)
115        if (parent === anchor) return yield* new PathError({ path: absolute, reason: "non_directory_ancestor" })
116        anchor = parent
117      }
118    })
119 
120    const resolve = Effect.fn("LocationMutation.resolve")(function* (input: ResolveInput) {
121      const relative = !path.isAbsolute(input.path)
122      const absolute = path.resolve(location.directory, input.path)
123      const lexicallyInternal = FSUtil.contains(location.directory, absolute)
124      if (relative && !lexicallyInternal) return yield* new PathError({ path: input.path, reason: "relative_escape" })
125 
126      const resolved = yield* resolvePath(absolute)
127      if (lexicallyInternal && !FSUtil.contains(locationRoot, resolved.canonical)) {
128        return yield* new PathError({ path: input.path, reason: "location_escape" })
129      }
130 
131      const external = !lexicallyInternal
132      const resource = external
133        ? slash(resolved.canonical)
134        : slash(path.relative(locationRoot, resolved.canonical) || ".")
135      const externalDirectory =
136        input.kind === "directory" && resolved.type === "Directory" ? resolved.canonical : resolved.directory
137      const externalResource = slash(path.join(externalDirectory, "*"))
138      return {
139        canonical: resolved.canonical,
140        resource,
141        externalDirectory: external
142          ? {
143              action: "external_directory",
144              directory: externalDirectory,
145              resource: externalResource,
146              save: externalResource,
147            }
148          : undefined,
149      } satisfies Target
150    })
151 
152    return Service.of({ resolve })
153  }),
154)
155 
156export const locationLayer = layer
157 
158export const node = makeLocationNode({
159  service: Service,
160  layer: layer.pipe(Layer.orDie),
161  deps: [FSUtil.node, Location.node],
162})
163