openAgent

1export * as Config from "./config"
2 
3import { makeLocationNode } from "./effect/app-node"
4import path from "path"
5import { type ParseError, parse } from "jsonc-parser"
6import { Context, Effect, Layer, Option, Schema } from "effect"
7import { Permission } from "@opencode-ai/schema/permission"
8import { FSUtil } from "./fs-util"
9import { Global } from "./global"
10import { Location } from "./location"
11import { Policy } from "./policy"
12import { AbsolutePath } from "./schema"
13import { ConfigAgent } from "./config/agent"
14import { ConfigAttachments } from "./config/attachments"
15import { ConfigCompaction } from "./config/compaction"
16import { ConfigCommand } from "./config/command"
17import { ConfigExperimental } from "./config/experimental"
18import { ConfigFormatter } from "./config/formatter"
19import { ConfigLSP } from "./config/lsp"
20import { ConfigMCP } from "./config/mcp"
21import { ConfigPlugin } from "./config/plugin"
22import { ConfigProvider } from "./config/provider"
23import { ConfigReference } from "./config/reference"
24import { ConfigToolOutput } from "./config/tool-output"
25import { ConfigWatcher } from "./config/watcher"
26import { ConfigV1 } from "./v1/config/config"
27import { ConfigMigrateV1 } from "./v1/config/migrate"
28 
29export class Info extends Schema.Class<Info>("Config.Info")({
30  $schema: Schema.optional(Schema.String).annotate({
31    description: "JSON schema reference for configuration validation",
32  }),
33  shell: Schema.String.pipe(Schema.optional).annotate({
34    description: "Default shell to use for terminal and shell tool execution",
35  }),
36  model: Schema.String.pipe(Schema.optional).annotate({
37    description: "Default model to use when no session or agent model is selected",
38  }),
39  default_agent: Schema.String.pipe(Schema.optional).annotate({
40    description: "Default primary agent to use when no session agent is selected",
41  }),
42  autoupdate: Schema.Union([Schema.Boolean, Schema.Literal("notify")])
43    .pipe(Schema.optional)
44    .annotate({
45      description: "Automatically update or notify when a new version is available",
46    }),
47  share: Schema.Literals(["manual", "auto", "disabled"]).pipe(Schema.optional).annotate({
48    description: "Control whether sessions may be shared manually, automatically, or not at all",
49  }),
50  enterprise: Schema.Struct({
51    url: Schema.String.pipe(Schema.optional),
52  })
53    .pipe(Schema.optional)
54    .annotate({
55      description: "Enterprise sharing service configuration",
56    }),
57  username: Schema.String.pipe(Schema.optional).annotate({
58    description: "Username displayed in conversations and used for telemetry identity",
59  }),
60  permissions: Permission.Ruleset.pipe(Schema.optional).annotate({
61    description: "Ordered tool permission rules applied to agent tool use",
62  }),
63  agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(Schema.optional).annotate({
64    description: "Named built-in agent overrides and custom agent definitions",
65  }),
66  snapshots: Schema.Boolean.pipe(Schema.optional).annotate({
67    description: "Enable snapshots used for undo and revert behavior",
68  }),
69  watcher: ConfigWatcher.Info.pipe(Schema.optional).annotate({
70    description: "Filesystem watcher configuration",
71  }),
72  formatter: ConfigFormatter.Info.pipe(Schema.optional).annotate({
73    description: "Enable built-in formatters or configure formatter overrides",
74  }),
75  lsp: ConfigLSP.Info.pipe(Schema.optional).annotate({
76    description: "Enable built-in language servers or configure server overrides",
77  }),
78  attachments: ConfigAttachments.Info.pipe(Schema.optional).annotate({
79    description: "Attachment processing configuration",
80  }),
81  tool_output: ConfigToolOutput.Info.pipe(Schema.optional).annotate({
82    description: "Tool output truncation thresholds",
83  }),
84  mcp: ConfigMCP.Info.pipe(Schema.optional).annotate({
85    description: "MCP server configuration",
86  }),
87  compaction: ConfigCompaction.Info.pipe(Schema.optional).annotate({
88    description: "Conversation compaction behavior",
89  }),
90  skills: Schema.String.pipe(Schema.Array, Schema.optional).annotate({
91    description: "Additional paths or URLs to discover skills from",
92  }),
93  commands: Schema.Record(Schema.String, ConfigCommand.Info).pipe(Schema.optional).annotate({
94    description: "Named slash command definitions",
95  }),
96  instructions: Schema.String.pipe(Schema.Array, Schema.optional).annotate({
97    description: "Additional paths or URLs supplying ambient instructions",
98  }),
99  references: ConfigReference.Info.pipe(Schema.optional).annotate({
100    description: "Named local directories or Git repositories available as external context",
101  }),
102  plugins: ConfigPlugin.Plugins.pipe(Schema.optional).annotate({
103    description: "Ordered external plugin packages to load",
104  }),
105  experimental: ConfigExperimental.Experimental.pipe(Schema.optional),
106  providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(Schema.optional),
107}) {}
108 
109export class Document extends Schema.Class<Document>("Config.Document")({
110  type: Schema.Literal("document"),
111  path: Schema.String.pipe(Schema.optional),
112  info: Info,
113}) {}
114 
115export class Directory extends Schema.Class<Directory>("Config.Directory")({
116  type: Schema.Literal("directory"),
117  path: AbsolutePath,
118}) {}
119 
120export type Entry = Document | Directory
121 
122export function latest<K extends keyof Info>(entries: readonly Entry[], key: K): Info[K] | undefined {
123  return entries
124    .filter((entry): entry is Document => entry.type === "document")
125    .findLast((entry) => entry.info[key] !== undefined)?.info[key]
126}
127 
128export interface Interface {
129  /** Returns location config documents and supplemental directories from lowest to highest priority. */
130  readonly entries: () => Effect.Effect<Entry[]>
131}
132 
133export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Config") {}
134 
135const layer = Layer.effect(
136  Service,
137  Effect.gen(function* () {
138    const fs = yield* FSUtil.Service
139    const global = yield* Global.Service
140    const location = yield* Location.Service
141    const policy = yield* Policy.Service
142    const names = ["opencode.json", "opencode.jsonc"]
143    const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
144    const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions)
145    const decodeV1Info = Schema.decodeUnknownOption(ConfigV1.Info, decodeOptions)
146 
147    const loadFile = Effect.fnUntraced(function* (filepath: string) {
148      const text = yield* fs.readFileStringSafe(filepath)
149      if (!text) return
150 
151      const errors: ParseError[] = []
152      const input: unknown = parse(text, errors, { allowTrailingComma: true })
153      if (errors.length) return
154 
155      const info = Option.getOrUndefined(
156        ConfigMigrateV1.isV1(input)
157          ? decodeV1Info(input).pipe(Option.map(ConfigMigrateV1.migrate), Option.flatMap(decodeInfo))
158          : decodeInfo(input),
159      )
160      if (!info) return
161      return new Document({ type: "document", path: filepath, info })
162    })
163 
164    const loadDirectory = Effect.fnUntraced(function* (directory: AbsolutePath) {
165      return [
166        ...(yield* Effect.forEach(names, (file) => loadFile(path.join(directory, file))).pipe(
167          Effect.map((configs) => configs.filter((config): config is Document => config !== undefined)),
168        )),
169        new Directory({ type: "directory", path: directory }),
170      ]
171    })
172 
173    const globalDirectory = AbsolutePath.make(global.config)
174    const locationIsGlobal = path.resolve(location.directory) === path.resolve(global.config)
175    // Read configuration once when this location opens. Later calls reuse these
176    // values until the location is reopened.
177    const discovered = locationIsGlobal
178      ? []
179      : yield* fs
180          .up({
181            targets: [".opencode", ...names.toReversed()],
182            start: location.directory,
183            stop: location.project.directory,
184          })
185          .pipe(Effect.orDie)
186    const directories = [
187      globalDirectory,
188      ...discovered
189        .filter((item) => path.basename(item) === ".opencode")
190        .toReversed()
191        .map((directory) => AbsolutePath.make(directory)),
192    ]
193    // A config closer to the opened directory should win over one higher up.
194    // Search starts nearby, so reverse the results before applying them.
195    const directPaths = discovered.filter((item) => path.basename(item) !== ".opencode").toReversed()
196    const direct = yield* Effect.forEach(directPaths, loadFile).pipe(
197      Effect.orDie,
198      Effect.map((configs) => configs.filter((config): config is Document => config !== undefined)),
199    )
200    const supplementary = yield* Effect.forEach(directories, loadDirectory).pipe(Effect.orDie)
201    // Apply general settings first and more specific settings last:
202    // global config, project files, then `.opencode` files.
203    const configs = [...(supplementary[0] ?? []), ...direct, ...supplementary.slice(1).flat()]
204    // Rules use the opposite order so a user-global rule can override a
205    // repository rule. Statement order inside each file stays unchanged.
206    yield* policy.load(
207      configs
208        .filter((config): config is Document => config.type === "document")
209        .toReversed()
210        .flatMap((config) => config.info.experimental?.policies ?? []),
211    )
212 
213    return Service.of({
214      entries: Effect.fn("Config.entries")(function* () {
215        return configs
216      }),
217    })
218  }),
219)
220 
221export const locationLayer = layer.pipe(Layer.provideMerge(Policy.locationLayer))
222 
223export const node = makeLocationNode({
224  service: Service,
225  layer,
226  deps: [FSUtil.node, Global.node, Location.node, Policy.node],
227})
228