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