feat(api): add experimental wellknown connections

packages/core/src/config.ts

@@ -6,6 +6,8 @@ import { type ParseError, parse } from "jsonc-parser"
 import { Context, Effect, Fiber, Layer, Option, PubSub, Schema, Stream } from "effect"
 import { Permission } from "@opencode-ai/schema/permission"
 import { Config as ConfigSchema } from "@opencode-ai/schema/config"
+import { Integration } from "@opencode-ai/schema/integration"
+import { Credential } from "./credential"
 import { EventV2 } from "./event"
 import { Watcher } from "./filesystem/watcher"
 import { FSUtil } from "./fs-util"
@@ -28,6 +30,7 @@ import { ConfigVariable } from "./config/variable"
 import { ConfigWatcher } from "./config/watcher"
 import { ConfigV1 } from "./v1/config/config"
 import { ConfigMigrateV1 } from "./v1/config/migrate"
+import { WellKnown } from "./wellknown"
 
 export class Info extends Schema.Class<Info>("Config.Info")({
   $schema: Schema.optional(Schema.String).annotate({
@@ -157,29 +160,67 @@ const layer = Layer.effect(
     const location = yield* Location.Service
     const watcher = yield* Watcher.Service
     const events = yield* EventV2.Service
+    const credentials = yield* Credential.Service
+    const wellknown = yield* WellKnown.Service
     const names = ["opencode.json", "opencode.jsonc"]
     const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
     const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions)
     const decodeV1Info = Schema.decodeUnknownOption(ConfigV1.Info, decodeOptions)
 
-    const loadFile = Effect.fnUntraced(function* (filepath: string) {
-      const text = yield* fs.readFileStringSafe(filepath)
-      if (!text) return
-      const substituted = yield* ConfigVariable.substitute({ type: "path", path: filepath, text })
-
+    const parseInfo = (text: string) => {
       const errors: ParseError[] = []
-      const input: unknown = parse(substituted, errors, { allowTrailingComma: true })
+      const input: unknown = parse(text, errors, { allowTrailingComma: true })
       if (errors.length) return
-
-      const info = Option.getOrUndefined(
+      return Option.getOrUndefined(
         ConfigMigrateV1.isV1(input)
           ? decodeV1Info(input).pipe(Option.map(ConfigMigrateV1.migrate), Option.flatMap(decodeInfo))
           : decodeInfo(input),
       )
+    }
+
+    const loadFile = Effect.fnUntraced(function* (filepath: string) {
+      const text = yield* fs.readFileStringSafe(filepath)
+      if (!text) return
+      const substituted = yield* ConfigVariable.substitute({ type: "path", path: filepath, text })
+      const info = parseInfo(substituted)
       if (!info) return
       return new Document({ type: "document", path: filepath, info })
     })
 
+    const loadWellknown = Effect.fn("Config.loadWellknown")(function* () {
+      const entries = yield* wellknown
+        .entries()
+        .pipe(
+          Effect.catch((error) =>
+            Effect.logWarning("failed to discover wellknown config", { error }).pipe(Effect.as([] as const)),
+          ),
+        )
+      return yield* Effect.forEach(entries, (entry) =>
+        Effect.gen(function* () {
+          const auth = entry.manifest.auth
+          if (!auth) return []
+          const credential = (yield* credentials.list(entry.integrationID)).findLast(
+            (credential) => credential.value.type === "key",
+          )
+          if (!credential || credential.value.type !== "key") return []
+          const variables = { [auth.env]: credential.value.key }
+          const configs = yield* wellknown.resolve(entry, variables).pipe(Effect.orDie)
+          return yield* Effect.forEach(configs, (config) =>
+            ConfigVariable.substitute({
+              type: "virtual",
+              source: entry.origin,
+              dir: entry.origin,
+              text: JSON.stringify(config),
+              env: variables,
+            }).pipe(
+              Effect.map(parseInfo),
+              Effect.map((info) => (info ? new Document({ type: "document", info }) : undefined)),
+            ),
+          ).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)))
+        }),
+      ).pipe(Effect.map((documents) => documents.flat()))
+    })
+
     const loadDirectory = Effect.fnUntraced(function* (directory: AbsolutePath) {
       return [
         ...(yield* Effect.forEach(names, (file) => loadFile(path.join(directory, file))).pipe(
@@ -201,7 +242,7 @@ const layer = Layer.effect(
               targets: [".opencode", ".claude", ".agents", ...names.toReversed()],
               start: location.directory,
             })
-          .pipe(Effect.orDie)
+            .pipe(Effect.orDie)
 
       // We load certain files from a few other folders in the ecosystem
       const claude = [
@@ -244,7 +285,14 @@ const layer = Layer.effect(
       )
 
       const supplementary = yield* Effect.forEach(directories, loadDirectory).pipe(Effect.orDie)
-      return [...claude, ...agents, ...(supplementary[0] ?? []), ...direct, ...supplementary.slice(1).flat()]
+      return [
+        ...claude,
+        ...agents,
+        ...(supplementary[0] ?? []),
+        ...direct,
+        ...supplementary.slice(1).flat(),
+        ...(yield* loadWellknown().pipe(Effect.orDie)),
+      ]
     })
 
     const initial = yield* discover()
@@ -276,15 +324,37 @@ const layer = Layer.effect(
       }
     })
 
+    const reload = Effect.fn("Config.reload")(function* () {
+      const next = yield* discover()
+      configs = next
+      yield* reconcile(next)
+      yield* events.publish(ConfigSchema.Event.Updated, {})
+    })
+
     yield* Stream.fromPubSub(updates).pipe(
       Stream.debounce("100 millis"),
       Stream.runForEach((update) =>
-        Effect.gen(function* () {
-          const next = yield* discover()
-          configs = next
-          yield* reconcile(next)
-          yield* events.publish(ConfigSchema.Event.Updated, {})
-        }).pipe(Effect.catchCause((cause) => Effect.logError("failed to reload config", { path: update.path, cause }))),
+        reload().pipe(
+          Effect.catchCause((cause) => Effect.logError("failed to reload config", { path: update.path, cause })),
+        ),
+      ),
+      Effect.forkScoped({ startImmediately: true }),
+    )
+    yield* events.subscribe(Integration.Event.ConnectionUpdated).pipe(
+      Stream.filterEffect((event) =>
+        wellknown.entries().pipe(
+          Effect.map((entries) => entries.some((entry) => entry.integrationID === event.data.integrationID)),
+          Effect.catch(() => Effect.succeed(false)),
+        ),
+      ),
+      Stream.runForEach(() =>
+        reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown config", { cause }))),
+      ),
+      Effect.forkScoped({ startImmediately: true }),
+    )
+    yield* wellknown.changes.pipe(
+      Stream.runForEach(() =>
+        reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown sources", { cause }))),
       ),
       Effect.forkScoped({ startImmediately: true }),
     )
@@ -301,5 +371,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Watcher.node, EventV2.node, FSUtil.node, Global.node, Location.node],
+  deps: [Watcher.node, EventV2.node, FSUtil.node, Global.node, Location.node, Credential.node, WellKnown.node],
 })