openAgent

1export * as Npm from "./npm"
2 
3import path from "path"
4import npa from "npm-package-arg"
5import { Effect, Schema, Context, Layer, Option, FileSystem } from "effect"
6import { NodeFileSystem } from "@effect/platform-node"
7import { FSUtil } from "./fs-util"
8import { Global } from "./global"
9import { EffectFlock } from "./util/effect-flock"
10import { makeGlobalNode } from "./effect/app-node"
11import { filesystem } from "./effect/app-node-platform"
12import { LayerNode } from "./effect/layer-node"
13import { makeRuntime } from "./effect/runtime"
14import { NpmConfig } from "./npm-config"
15 
16export class InstallFailedError extends Schema.TaggedErrorClass<InstallFailedError>()("NpmInstallFailedError", {
17  add: Schema.Array(Schema.String).pipe(Schema.optional),
18  dir: Schema.String,
19  cause: Schema.optional(Schema.Defect()),
20}) {}
21 
22export interface EntryPoint {
23  readonly directory: string
24  readonly entrypoint?: string
25}
26 
27export interface Interface {
28  readonly add: (pkg: string) => Effect.Effect<EntryPoint, InstallFailedError | EffectFlock.LockError>
29  readonly install: (
30    dir: string,
31    input?: {
32      add: {
33        name: string
34        version?: string
35      }[]
36    },
37  ) => Effect.Effect<void, EffectFlock.LockError | InstallFailedError>
38  readonly which: (pkg: string, bin?: string) => Effect.Effect<string | undefined>
39}
40 
41export class Service extends Context.Service<Service, Interface>()("@opencode/Npm") {}
42 
43const illegal = process.platform === "win32" ? new Set(["<", ">", ":", '"', "|", "?", "*"]) : undefined
44 
45export function sanitize(pkg: string) {
46  if (!illegal) return pkg
47  return Array.from(pkg, (char) => (illegal.has(char) || char.charCodeAt(0) < 32 ? "_" : char)).join("")
48}
49 
50const resolveEntryPoint = (name: string, dir: string): EntryPoint => {
51  let entrypoint: string | undefined
52  try {
53    entrypoint = typeof Bun !== "undefined" ? import.meta.resolve(name, dir) : import.meta.resolve(dir)
54  } catch {
55    entrypoint = undefined
56  }
57  return {
58    directory: dir,
59    entrypoint,
60  }
61}
62 
63interface ArboristNode {
64  name: string
65  path: string
66}
67 
68interface ArboristTree {
69  edgesOut: Map<string, { to?: ArboristNode }>
70}
71 
72const layer = Layer.effect(
73  Service,
74  Effect.gen(function* () {
75    const afs = yield* FSUtil.Service
76    const global = yield* Global.Service
77    const fs = yield* FileSystem.FileSystem
78    const flock = yield* EffectFlock.Service
79    const directory = (pkg: string) => path.join(global.cache, "packages", sanitize(pkg))
80    const reify = (input: { dir: string; add?: string[] }) =>
81      Effect.gen(function* () {
82        yield* flock.acquire(`npm-install:${input.dir}`)
83        const { Arborist } = yield* Effect.promise(() => import("@npmcli/arborist"))
84        const add = input.add ?? []
85        const npmOptions = yield* NpmConfig.load(input.dir)
86        const arborist = new Arborist({
87          ...npmOptions,
88          path: input.dir,
89          binLinks: true,
90          progress: false,
91          savePrefix: "",
92          ignoreScripts: true,
93        })
94        return yield* Effect.tryPromise({
95          try: () =>
96            arborist.reify({
97              ...npmOptions,
98              add,
99              save: true,
100              saveType: "prod",
101            }),
102          catch: (cause) =>
103            new InstallFailedError({
104              cause,
105              add,
106              dir: input.dir,
107            }),
108        }) as Effect.Effect<ArboristTree, InstallFailedError>
109      }).pipe(
110        Effect.withSpan("Npm.reify", {
111          attributes: input,
112        }),
113      )
114 
115    const add = Effect.fn("Npm.add")(function* (pkg: string) {
116      const dir = directory(pkg)
117      const name = (() => {
118        try {
119          return npa(pkg).name ?? pkg
120        } catch {
121          return pkg
122        }
123      })()
124 
125      if (yield* afs.existsSafe(path.join(dir, "node_modules", name))) {
126        return resolveEntryPoint(name, path.join(dir, "node_modules", name))
127      }
128 
129      const tree = yield* reify({ dir, add: [pkg] })
130      const first = tree.edgesOut.values().next().value?.to
131      if (!first) {
132        const result = resolveEntryPoint(name, path.join(dir, "node_modules", name))
133        if (result.entrypoint) return result
134        return yield* new InstallFailedError({ add: [pkg], dir })
135      }
136      return resolveEntryPoint(first.name, first.path)
137    }, Effect.scoped)
138 
139    const install: Interface["install"] = Effect.fn("Npm.install")(function* (dir, input) {
140      const canWrite = yield* afs.access(dir, { writable: true }).pipe(
141        Effect.as(true),
142        Effect.orElseSucceed(() => false),
143      )
144      if (!canWrite) return
145 
146      const add = input?.add.map((pkg) => [pkg.name, pkg.version].filter(Boolean).join("@")) ?? []
147      if (
148        yield* Effect.gen(function* () {
149          const nodeModulesExists = yield* afs.existsSafe(path.join(dir, "node_modules"))
150          if (!nodeModulesExists) {
151            yield* reify({ add, dir })
152            return true
153          }
154          return false
155        }).pipe(Effect.withSpan("Npm.checkNodeModules"))
156      )
157        return
158 
159      yield* Effect.gen(function* () {
160        const pkg = yield* afs.readJson(path.join(dir, "package.json")).pipe(Effect.orElseSucceed(() => ({})))
161        const lock = yield* afs.readJson(path.join(dir, "package-lock.json")).pipe(Effect.orElseSucceed(() => ({})))
162 
163        const pkgAny = pkg as any
164        const lockAny = lock as any
165        const declared = new Set([
166          ...Object.keys(pkgAny?.dependencies || {}),
167          ...Object.keys(pkgAny?.devDependencies || {}),
168          ...Object.keys(pkgAny?.peerDependencies || {}),
169          ...Object.keys(pkgAny?.optionalDependencies || {}),
170          ...(input?.add || []).map((pkg) => pkg.name),
171        ])
172 
173        const root = lockAny?.packages?.[""] || {}
174        const locked = new Set([
175          ...Object.keys(root?.dependencies || {}),
176          ...Object.keys(root?.devDependencies || {}),
177          ...Object.keys(root?.peerDependencies || {}),
178          ...Object.keys(root?.optionalDependencies || {}),
179        ])
180 
181        for (const name of declared) {
182          if (!locked.has(name)) {
183            yield* reify({ dir, add })
184            return
185          }
186        }
187      }).pipe(Effect.withSpan("Npm.checkDirty"))
188 
189      return
190    }, Effect.scoped)
191 
192    const which = Effect.fn("Npm.which")(function* (pkg: string, bin?: string) {
193      const dir = directory(pkg)
194      const binDir = path.join(dir, "node_modules", ".bin")
195 
196      const pick = Effect.fnUntraced(function* () {
197        const files = yield* fs.readDirectory(binDir).pipe(Effect.catch(() => Effect.succeed([] as string[])))
198 
199        if (files.length === 0) return Option.none<string>()
200        // Caller picked a specific bin (e.g. pyright exposes both `pyright` and
201        // `pyright-langserver`); trust the hint if the package provides it.
202        if (bin) return files.includes(bin) ? Option.some(bin) : Option.none<string>()
203        if (files.length === 1) return Option.some(files[0])
204 
205        const pkgJson = yield* afs.readJson(path.join(dir, "node_modules", pkg, "package.json")).pipe(Effect.option)
206 
207        if (Option.isSome(pkgJson)) {
208          const parsed = pkgJson.value as { bin?: string | Record<string, string> }
209          if (parsed?.bin) {
210            const unscoped = pkg.startsWith("@") ? pkg.split("/")[1] : pkg
211            const parsedBin = parsed.bin
212            if (typeof parsedBin === "string") return Option.some(unscoped)
213            const keys = Object.keys(parsedBin)
214            if (keys.length === 1) return Option.some(keys[0])
215            return parsedBin[unscoped] ? Option.some(unscoped) : Option.some(keys[0])
216          }
217        }
218 
219        return Option.some(files[0])
220      })
221 
222      return Option.getOrUndefined(
223        yield* Effect.gen(function* () {
224          const bin = yield* pick()
225          if (Option.isSome(bin)) {
226            return Option.some(path.join(binDir, bin.value))
227          }
228 
229          yield* fs.remove(path.join(dir, "package-lock.json")).pipe(Effect.orElseSucceed(() => {}))
230 
231          yield* add(pkg)
232 
233          const resolved = yield* pick()
234          if (Option.isNone(resolved)) return Option.none<string>()
235          return Option.some(path.join(binDir, resolved.value))
236        }).pipe(
237          Effect.scoped,
238          Effect.orElseSucceed(() => Option.none<string>()),
239        ),
240      )
241    })
242 
243    return Service.of({
244      add,
245      install,
246      which,
247    })
248  }),
249)
250 
251export const node = makeGlobalNode({
252  service: Service,
253  layer: layer,
254  deps: [FSUtil.node, Global.node, filesystem, EffectFlock.node],
255})
256 
257const { runPromise } = makeRuntime(Service, LayerNode.compile(node))
258 
259export async function install(...args: Parameters<Interface["install"]>) {
260  return runPromise((svc) => svc.install(...args))
261}
262 
263export async function add(...args: Parameters<Interface["add"]>) {
264  return runPromise((svc) => svc.add(...args))
265}
266 
267export async function which(...args: Parameters<Interface["which"]>) {
268  return runPromise((svc) => svc.which(...args))
269}
270