openAgent

1import { LayerNode } from "@opencode-ai/core/effect/layer-node"
2import { httpClient, path } from "@opencode-ai/core/effect/app-node-platform"
3import { NodePath } from "@effect/platform-node"
4import { Effect, Layer, Path, Schema, Context } from "effect"
5import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
6import { withTransientReadRetry } from "@/util/effect-http-client"
7import { FSUtil } from "@opencode-ai/core/fs-util"
8import { Global } from "@opencode-ai/core/global"
9 
10const skillConcurrency = 4
11const fileConcurrency = 8
12 
13class IndexSkill extends Schema.Class<IndexSkill>("IndexSkill")({
14  name: Schema.String,
15  files: Schema.Array(Schema.String),
16  version: Schema.optional(Schema.String),
17}) {}
18 
19class Index extends Schema.Class<Index>("Index")({
20  skills: Schema.Array(IndexSkill),
21}) {}
22 
23export interface Interface {
24  readonly pull: (url: string) => Effect.Effect<string[]>
25}
26 
27export class Service extends Context.Service<Service, Interface>()("@opencode/SkillDiscovery") {}
28 
29const layer: Layer.Layer<Service, never, FSUtil.Service | Path.Path | HttpClient.HttpClient> = Layer.effect(
30  Service,
31  Effect.gen(function* () {
32    const fs = yield* FSUtil.Service
33    const path = yield* Path.Path
34    const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
35    const cache = path.join(Global.Path.cache, "skills")
36 
37    const download = Effect.fn("Discovery.download")(function* (url: string, dest: string) {
38      if (yield* fs.exists(dest).pipe(Effect.orDie)) return true
39 
40      return yield* HttpClientRequest.get(url).pipe(
41        http.execute,
42        Effect.flatMap((res) => res.arrayBuffer),
43        Effect.flatMap((body) => fs.writeWithDirs(dest, new Uint8Array(body))),
44        Effect.as(true),
45        Effect.catch((err) => Effect.logError("failed to download", { url: url, error: err }).pipe(Effect.as(false))),
46      )
47    })
48 
49    const pull = Effect.fn("Discovery.pull")(function* (url: string) {
50      const base = url.endsWith("/") ? url : `${url}/`
51      const index = new URL("index.json", base).href
52      const host = base.slice(0, -1)
53 
54      yield* Effect.logInfo("fetching index", { url: index })
55 
56      const data = yield* HttpClientRequest.get(index).pipe(
57        HttpClientRequest.acceptJson,
58        http.execute,
59        Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)),
60        Effect.catch((err) =>
61          Effect.logError("failed to fetch index", { url: index, error: err }).pipe(Effect.as(null)),
62        ),
63      )
64 
65      if (!data) return []
66 
67      const missing = data.skills.filter((skill) => !skill.files.includes("SKILL.md"))
68      yield* Effect.forEach(
69        missing,
70        (skill) => Effect.logWarning("skill entry missing SKILL.md", { url: index, skill: skill.name }),
71        { discard: true },
72      )
73      const list = data.skills.filter((skill) => skill.files.includes("SKILL.md"))
74 
75      const dirs = yield* Effect.forEach(
76        list,
77        (skill) =>
78          Effect.gen(function* () {
79            const root = path.join(cache, skill.name)
80            const versionFile = path.join(root, ".opencode-version")
81            const version = skill.version
82            const current =
83              version === undefined
84                ? undefined
85                : yield* fs.readFileStringSafe(versionFile).pipe(Effect.catch(() => Effect.succeed(undefined)))
86 
87            if (version === undefined || current === version) {
88              yield* Effect.forEach(
89                skill.files,
90                (file) => download(new URL(file, `${host}/${skill.name}/`).href, path.join(root, file)),
91                { concurrency: fileConcurrency, discard: true },
92              )
93            } else {
94              const token = crypto.randomUUID()
95              const staging = `${root}.tmp-${token}`
96              const backup = `${root}.old-${token}`
97              yield* Effect.gen(function* () {
98                const downloaded = yield* Effect.forEach(
99                  skill.files,
100                  (file) => download(new URL(file, `${host}/${skill.name}/`).href, path.join(staging, file)),
101                  { concurrency: fileConcurrency },
102                )
103                if (!downloaded.every(Boolean)) return
104                if (!(yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie))) return
105                yield* fs.writeFileString(path.join(staging, ".opencode-version"), version)
106                yield* Effect.uninterruptible(
107                  Effect.gen(function* () {
108                    const cached = yield* fs.exists(root).pipe(Effect.orDie)
109                    if (cached) yield* fs.rename(root, backup)
110                    yield* fs.rename(staging, root).pipe(
111                      Effect.catch((error) =>
112                        Effect.gen(function* () {
113                          if (cached) yield* fs.rename(backup, root).pipe(Effect.ignore)
114                          return yield* Effect.fail(error)
115                        }),
116                      ),
117                    )
118                    if (cached) yield* fs.remove(backup, { recursive: true, force: true }).pipe(Effect.ignore)
119                  }),
120                )
121              }).pipe(
122                Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })),
123                Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)),
124              )
125            }
126            return (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) ? root : null
127          }),
128        { concurrency: skillConcurrency },
129      )
130 
131      return dirs.filter((dir): dir is string => dir !== null)
132    })
133 
134    return Service.of({ pull })
135  }),
136)
137 
138export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node, path, httpClient] })
139 
140export * as Discovery from "./discovery"
141