@sleepy-ai/cli 0.1.15 → 0.1.16

package/src/installation/index.ts

@@ -0,0 +1,362 @@
+import { Effect, Layer, Schema, Context, Stream } from "effect"
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
+import { withTransientReadRetry } from "@/util/effect-http-client"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import z from "zod"
+import path from "path"
+import { BusEvent } from "@/bus/bus-event"
+import { Flag } from "../flag/flag"
+import { Log } from "../util"
+import semver from "semver"
+import { InstallationChannel, InstallationVersion } from "./version"
+
+const log = Log.create({ service: "installation" })
+
+const PACKAGE_NAME = "@sleepy-ai/cli"
+
+export type Method = "curl" | "npm" | "pnpm" | "bun" | "brew" | "scoop" | "choco" | "unknown"
+
+export type ReleaseType = "patch" | "minor" | "major"
+
+export const Event = {
+  Updated: BusEvent.define(
+    "installation.updated",
+    z.object({
+      version: z.string(),
+    }),
+  ),
+  UpdateAvailable: BusEvent.define(
+    "installation.update-available",
+    z.object({
+      version: z.string(),
+    }),
+  ),
+}
+
+export function getReleaseType(current: string, latest: string): ReleaseType {
+  const currMajor = semver.major(current)
+  const currMinor = semver.minor(current)
+  const newMajor = semver.major(latest)
+  const newMinor = semver.minor(latest)
+
+  if (newMajor > currMajor) return "major"
+  if (newMinor > currMinor) return "minor"
+  return "patch"
+}
+
+export const Info = z
+  .object({
+    version: z.string(),
+    latest: z.string(),
+  })
+  .meta({
+    ref: "InstallationInfo",
+  })
+export type Info = z.infer<typeof Info>
+
+export const USER_AGENT = `sleepycode/${InstallationChannel}/${InstallationVersion}/${Flag.SLEEPYCODE_CLIENT}`
+
+export function isPreview() {
+  return InstallationChannel !== "latest"
+}
+
+export function isLocal() {
+  return InstallationChannel === "local"
+}
+
+export class UpgradeFailedError extends Schema.TaggedErrorClass<UpgradeFailedError>()("UpgradeFailedError", {
+  stderr: Schema.String,
+}) {}
+
+// TODO(sleepycode): uncomment when corresponding channels are supported
+// const GitHubRelease = Schema.Struct({ tag_name: Schema.String })
+const NpmPackage = Schema.Struct({ version: Schema.String })
+// const BrewFormula = Schema.Struct({ versions: Schema.Struct({ stable: Schema.String }) })
+// const BrewInfoV2 = Schema.Struct({
+//   formulae: Schema.Array(Schema.Struct({ versions: Schema.Struct({ stable: Schema.String }) })),
+// })
+// const ChocoPackage = Schema.Struct({
+//   d: Schema.Struct({ results: Schema.Array(Schema.Struct({ Version: Schema.String })) }),
+// })
+// const ScoopManifest = NpmPackage
+
+export interface Interface {
+  readonly info: () => Effect.Effect<Info>
+  readonly method: () => Effect.Effect<Method>
+  readonly latest: (method?: Method) => Effect.Effect<string>
+  readonly upgrade: (method: Method, target: string) => Effect.Effect<void, UpgradeFailedError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@sleepycode/Installation") {}
+
+export const layer: Layer.Layer<Service, never, HttpClient.HttpClient | ChildProcessSpawner.ChildProcessSpawner> =
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const http = yield* HttpClient.HttpClient
+      const httpOk = HttpClient.filterStatusOk(withTransientReadRetry(http))
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+
+      const text = Effect.fnUntraced(
+        function* (cmd: string[], opts?: { cwd?: string; env?: Record<string, string> }) {
+          const proc = ChildProcess.make(cmd[0], cmd.slice(1), {
+            cwd: opts?.cwd,
+            env: opts?.env,
+            extendEnv: true,
+          })
+          const handle = yield* spawner.spawn(proc)
+          const out = yield* Stream.mkString(Stream.decodeText(handle.stdout))
+          yield* handle.exitCode
+          return out
+        },
+        Effect.scoped,
+        Effect.catch(() => Effect.succeed("")),
+      )
+
+      const run = Effect.fnUntraced(
+        function* (cmd: string[], opts?: { cwd?: string; env?: Record<string, string> }) {
+          const proc = ChildProcess.make(cmd[0], cmd.slice(1), {
+            cwd: opts?.cwd,
+            env: opts?.env,
+            extendEnv: true,
+          })
+          const handle = yield* spawner.spawn(proc)
+          const [stdout, stderr] = yield* Effect.all(
+            [Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))],
+            { concurrency: 2 },
+          )
+          const code = yield* handle.exitCode
+          return { code, stdout, stderr }
+        },
+        Effect.scoped,
+        Effect.catch(() => Effect.succeed({ code: ChildProcessSpawner.ExitCode(1), stdout: "", stderr: "" })),
+      )
+
+      // TODO(sleepycode): uncomment when sleepycode is published to homebrew
+      // const getBrewFormula = Effect.fnUntraced(function* () {
+      //   const tapFormula = yield* text(["brew", "list", "--formula", "anomalyco/tap/opencode"])
+      //   if (tapFormula.includes("opencode")) return "anomalyco/tap/opencode"
+      //   const coreFormula = yield* text(["brew", "list", "--formula", "opencode"])
+      //   if (coreFormula.includes("opencode")) return "opencode"
+      //   return "opencode"
+      // })
+
+      const upgradeCurl = Effect.fnUntraced(
+        function* (target: string) {
+          const response = yield* httpOk.execute(HttpClientRequest.get("https://www.sleepyai.org"))
+          const body = yield* response.text
+          const bodyBytes = new TextEncoder().encode(body)
+          const proc = ChildProcess.make("bash", [], {
+            stdin: Stream.make(bodyBytes),
+            env: { VERSION: target },
+            extendEnv: true,
+          })
+          const handle = yield* spawner.spawn(proc)
+          const [stdout, stderr] = yield* Effect.all(
+            [Stream.mkString(Stream.decodeText(handle.stdout)), Stream.mkString(Stream.decodeText(handle.stderr))],
+            { concurrency: 2 },
+          )
+          const code = yield* handle.exitCode
+          return { code, stdout, stderr }
+        },
+        Effect.scoped,
+        Effect.orDie,
+      )
+
+      const methodImpl = Effect.fn("Installation.method")(function* () {
+        if (process.execPath.includes(path.join(".sleepycode", "bin"))) return "curl" as Method
+        if (process.execPath.includes(path.join(".local", "bin"))) return "curl" as Method
+        const exec = process.execPath.toLowerCase()
+
+        const checks: Array<{ name: Method; command: () => Effect.Effect<string> }> = [
+          { name: "npm", command: () => text(["npm", "list", "-g", "--depth=0"]) },
+          { name: "pnpm", command: () => text(["pnpm", "list", "-g", "--depth=0"]) },
+          { name: "bun", command: () => text(["bun", "pm", "ls", "-g"]) },
+          // TODO(sleepycode): uncomment when sleepycode is published to these channels
+          // { name: "brew", command: () => text(["brew", "list", "--formula", "opencode"]) },
+          // { name: "scoop", command: () => text(["scoop", "list", "opencode"]) },
+          // { name: "choco", command: () => text(["choco", "list", "--limit-output", "opencode"]) },
+        ]
+
+        checks.sort((a, b) => {
+          const aMatches = exec.includes(a.name)
+          const bMatches = exec.includes(b.name)
+          if (aMatches && !bMatches) return -1
+          if (!aMatches && bMatches) return 1
+          return 0
+        })
+
+        for (const check of checks) {
+          const output = yield* check.command()
+          if (output.includes(PACKAGE_NAME)) {
+            return check.name
+          }
+        }
+
+        return "unknown" as Method
+      })
+
+      const latestImpl = Effect.fn("Installation.latest")(function* (installMethod?: Method) {
+        const detectedMethod = installMethod || (yield* methodImpl())
+
+        // TODO(sleepycode): uncomment when sleepycode is published to homebrew
+        // if (detectedMethod === "brew") {
+        //   const formula = yield* getBrewFormula()
+        //   if (formula.includes("/")) {
+        //     const infoJson = yield* text(["brew", "info", "--json=v2", formula])
+        //     const info = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(BrewInfoV2))(infoJson)
+        //     return info.formulae[0].versions.stable
+        //   }
+        //   const response = yield* httpOk.execute(
+        //     HttpClientRequest.get("https://formulae.brew.sh/api/formula/opencode.json").pipe(
+        //       HttpClientRequest.acceptJson,
+        //     ),
+        //   )
+        //   const data = yield* HttpClientResponse.schemaBodyJson(BrewFormula)(response)
+        //   return data.versions.stable
+        // }
+
+        if (detectedMethod === "curl") {
+          const headers = yield* text([
+            "curl",
+            "-sI",
+            "https://github.com/XiaomiSleepy/Sleepy-Code/releases/latest",
+          ])
+          const match = headers.match(/^location:.*\/tag\/v([0-9][^\s/]*)/im)
+          if (match) return match[1]
+          return yield* Effect.die(new Error("failed to resolve latest version from GitHub releases redirect"))
+        }
+
+        if (detectedMethod === "npm" || detectedMethod === "bun" || detectedMethod === "pnpm") {
+          const r = (yield* text(["npm", "config", "get", "registry"])).trim()
+          const reg = r || "https://registry.npmjs.org"
+          const registry = reg.endsWith("/") ? reg.slice(0, -1) : reg
+          const response = yield* httpOk.execute(
+            HttpClientRequest.get(`${registry}/${encodeURIComponent(PACKAGE_NAME)}/${InstallationChannel}`).pipe(
+              HttpClientRequest.acceptJson,
+            ),
+          )
+          const data = yield* HttpClientResponse.schemaBodyJson(NpmPackage)(response)
+          return data.version
+        }
+
+        // TODO(sleepycode): uncomment when sleepycode is published to chocolatey
+        // if (detectedMethod === "choco") {
+        //   const response = yield* httpOk.execute(
+        //     HttpClientRequest.get(
+        //       "https://community.chocolatey.org/api/v2/Packages?$filter=Id%20eq%20%27opencode%27%20and%20IsLatestVersion&$select=Version",
+        //     ).pipe(HttpClientRequest.setHeaders({ Accept: "application/json;odata=verbose" })),
+        //   )
+        //   const data = yield* HttpClientResponse.schemaBodyJson(ChocoPackage)(response)
+        //   return data.d.results[0].Version
+        // }
+
+        // TODO(sleepycode): uncomment when sleepycode is published to scoop
+        // if (detectedMethod === "scoop") {
+        //   const response = yield* httpOk.execute(
+        //     HttpClientRequest.get(
+        //       "https://raw.githubusercontent.com/ScoopInstaller/Main/master/bucket/opencode.json",
+        //     ).pipe(HttpClientRequest.setHeaders({ Accept: "application/json" })),
+        //   )
+        //   const data = yield* HttpClientResponse.schemaBodyJson(ScoopManifest)(response)
+        //   return data.version
+        // }
+
+        // TODO(sleepycode): uncomment when sleepycode has github releases
+        // const response = yield* httpOk.execute(
+        //   HttpClientRequest.get("https://api.github.com/repos/anomalyco/opencode/releases/latest").pipe(
+        //     HttpClientRequest.acceptJson,
+        //   ),
+        // )
+        // const data = yield* HttpClientResponse.schemaBodyJson(GitHubRelease)(response)
+        // return data.tag_name.replace(/^v/, "")
+
+        log.warn("unsupported update channel, skipping", { method: detectedMethod })
+        return yield* Effect.die(new Error(`unsupported update channel: ${detectedMethod}`))
+      }, Effect.orDie)
+
+      const upgradeImpl = Effect.fn("Installation.upgrade")(function* (m: Method, target: string) {
+        let result: { code: ChildProcessSpawner.ExitCode; stdout: string; stderr: string } | undefined
+        switch (m) {
+          case "curl":
+            result = yield* upgradeCurl(target)
+            break
+          case "npm":
+            result = yield* run(["npm", "install", "-g", `${PACKAGE_NAME}@${target}`])
+            break
+          case "pnpm":
+            result = yield* run(["pnpm", "install", "-g", `${PACKAGE_NAME}@${target}`])
+            break
+          case "bun":
+            result = yield* run(["bun", "install", "-g", `${PACKAGE_NAME}@${target}`])
+            break
+          // TODO(sleepycode): uncomment when sleepycode is published to homebrew
+          // case "brew": {
+          //   const formula = yield* getBrewFormula()
+          //   const env = { HOMEBREW_NO_AUTO_UPDATE: "1" }
+          //   if (formula.includes("/")) {
+          //     const tap = yield* run(["brew", "tap", "anomalyco/tap"], { env })
+          //     if (tap.code !== 0) {
+          //       result = tap
+          //       break
+          //     }
+          //     const repo = yield* text(["brew", "--repo", "anomalyco/tap"])
+          //     const dir = repo.trim()
+          //     if (dir) {
+          //       const pull = yield* run(["git", "pull", "--ff-only"], { cwd: dir, env })
+          //       if (pull.code !== 0) {
+          //         result = pull
+          //         break
+          //       }
+          //     }
+          //   }
+          //   result = yield* run(["brew", "upgrade", formula], { env })
+          //   break
+          // }
+          // TODO(sleepycode): uncomment when sleepycode is published to chocolatey
+          // case "choco":
+          //   result = yield* run(["choco", "upgrade", "opencode", `--version=${target}`, "-y"])
+          //   break
+          // TODO(sleepycode): uncomment when sleepycode is published to scoop
+          // case "scoop":
+          //   result = yield* run(["scoop", "install", `opencode@${target}`])
+          //   break
+          default:
+            return yield* new UpgradeFailedError({ stderr: `Unknown method: ${m}` })
+        }
+        if (!result || result.code !== 0) {
+          // TODO(sleepycode): restore choco-specific error when choco channel is supported
+          // const stderr = m === "choco" ? "not running from an elevated command shell" : result?.stderr || ""
+          const stderr = result?.stderr || ""
+          return yield* new UpgradeFailedError({ stderr })
+        }
+        log.info("upgraded", {
+          method: m,
+          target,
+          stdout: result.stdout,
+          stderr: result.stderr,
+        })
+        yield* text([process.execPath, "--version"])
+      })
+
+      return Service.of({
+        info: Effect.fn("Installation.info")(function* () {
+          return {
+            version: InstallationVersion,
+            latest: yield* latestImpl(),
+          }
+        }),
+        method: methodImpl,
+        latest: latestImpl,
+        upgrade: upgradeImpl,
+      })
+    }),
+  )
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(CrossSpawnSpawner.defaultLayer),
+)
+
+export * as Installation from "."

package/src/installation/version.ts

@@ -0,0 +1,8 @@
+declare global {
+  const SLEEPYCODE_VERSION: string
+  const SLEEPYCODE_CHANNEL: string
+}
+
+export const InstallationVersion = typeof SLEEPYCODE_VERSION === "string" ? SLEEPYCODE_VERSION : "local"
+export const InstallationChannel = typeof SLEEPYCODE_CHANNEL === "string" ? SLEEPYCODE_CHANNEL : "local"
+export const InstallationLocal = InstallationChannel === "local"

package/src/lsp/client.ts

@@ -0,0 +1,249 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import path from "path"
+import { pathToFileURL, fileURLToPath } from "url"
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node"
+import type { Diagnostic as VSCodeDiagnostic } from "vscode-languageserver-types"
+import { Log } from "../util"
+import { Process } from "../util"
+import { LANGUAGE_EXTENSIONS } from "./language"
+import z from "zod"
+import type * as LSPServer from "./server"
+import { NamedError } from "@sleepy-ai/shared/util/error"
+import { withTimeout } from "../util/timeout"
+import { Filesystem } from "../util"
+
+const DIAGNOSTICS_DEBOUNCE_MS = 150
+
+const log = Log.create({ service: "lsp.client" })
+
+export type Info = NonNullable<Awaited<ReturnType<typeof create>>>
+
+export type Diagnostic = VSCodeDiagnostic
+
+export const InitializeError = NamedError.create(
+  "LSPInitializeError",
+  z.object({
+    serverID: z.string(),
+  }),
+)
+
+export const Event = {
+  Diagnostics: BusEvent.define(
+    "lsp.client.diagnostics",
+    z.object({
+      serverID: z.string(),
+      path: z.string(),
+    }),
+  ),
+}
+
+export async function create(input: { serverID: string; server: LSPServer.Handle; root: string; directory: string }) {
+  const l = log.clone().tag("serverID", input.serverID)
+  l.info("starting client")
+
+  const connection = createMessageConnection(
+    new StreamMessageReader(input.server.process.stdout as any),
+    new StreamMessageWriter(input.server.process.stdin as any),
+  )
+
+  const diagnostics = new Map<string, Diagnostic[]>()
+  connection.onNotification("textDocument/publishDiagnostics", (params) => {
+    const filePath = Filesystem.normalizePath(fileURLToPath(params.uri))
+    l.info("textDocument/publishDiagnostics", {
+      path: filePath,
+      count: params.diagnostics.length,
+    })
+    const exists = diagnostics.has(filePath)
+    diagnostics.set(filePath, params.diagnostics)
+    if (!exists && input.serverID === "typescript") return
+    Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+  })
+  connection.onRequest("window/workDoneProgress/create", (params) => {
+    l.info("window/workDoneProgress/create", params)
+    return null
+  })
+  connection.onRequest("workspace/configuration", async () => {
+    // Return server initialization options
+    return [input.server.initialization ?? {}]
+  })
+  connection.onRequest("client/registerCapability", async () => {})
+  connection.onRequest("client/unregisterCapability", async () => {})
+  connection.onRequest("workspace/workspaceFolders", async () => [
+    {
+      name: "workspace",
+      uri: pathToFileURL(input.root).href,
+    },
+  ])
+  connection.listen()
+
+  l.info("sending initialize")
+  await withTimeout(
+    connection.sendRequest("initialize", {
+      rootUri: pathToFileURL(input.root).href,
+      processId: input.server.process.pid,
+      workspaceFolders: [
+        {
+          name: "workspace",
+          uri: pathToFileURL(input.root).href,
+        },
+      ],
+      initializationOptions: {
+        ...input.server.initialization,
+      },
+      capabilities: {
+        window: {
+          workDoneProgress: true,
+        },
+        workspace: {
+          configuration: true,
+          didChangeWatchedFiles: {
+            dynamicRegistration: true,
+          },
+        },
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+          },
+          publishDiagnostics: {
+            versionSupport: true,
+          },
+        },
+      },
+    }),
+    45_000,
+  ).catch((err) => {
+    l.error("initialize error", { error: err })
+    throw new InitializeError(
+      { serverID: input.serverID },
+      {
+        cause: err,
+      },
+    )
+  })
+
+  await connection.sendNotification("initialized", {})
+
+  if (input.server.initialization) {
+    await connection.sendNotification("workspace/didChangeConfiguration", {
+      settings: input.server.initialization,
+    })
+  }
+
+  const files: {
+    [path: string]: number
+  } = {}
+
+  const result = {
+    root: input.root,
+    get serverID() {
+      return input.serverID
+    },
+    get connection() {
+      return connection
+    },
+    notify: {
+      async open(request: { path: string }) {
+        request.path = path.isAbsolute(request.path) ? request.path : path.resolve(input.directory, request.path)
+        const text = await Filesystem.readText(request.path)
+        const extension = path.extname(request.path)
+        const languageId = LANGUAGE_EXTENSIONS[extension] ?? "plaintext"
+
+        const version = files[request.path]
+        if (version !== undefined) {
+          log.info("workspace/didChangeWatchedFiles", request)
+          await connection.sendNotification("workspace/didChangeWatchedFiles", {
+            changes: [
+              {
+                uri: pathToFileURL(request.path).href,
+                type: 2, // Changed
+              },
+            ],
+          })
+
+          const next = version + 1
+          files[request.path] = next
+          log.info("textDocument/didChange", {
+            path: request.path,
+            version: next,
+          })
+          await connection.sendNotification("textDocument/didChange", {
+            textDocument: {
+              uri: pathToFileURL(request.path).href,
+              version: next,
+            },
+            contentChanges: [{ text }],
+          })
+          return
+        }
+
+        log.info("workspace/didChangeWatchedFiles", request)
+        await connection.sendNotification("workspace/didChangeWatchedFiles", {
+          changes: [
+            {
+              uri: pathToFileURL(request.path).href,
+              type: 1, // Created
+            },
+          ],
+        })
+
+        log.info("textDocument/didOpen", request)
+        diagnostics.delete(request.path)
+        await connection.sendNotification("textDocument/didOpen", {
+          textDocument: {
+            uri: pathToFileURL(request.path).href,
+            languageId,
+            version: 0,
+            text,
+          },
+        })
+        files[request.path] = 0
+        return
+      },
+    },
+    get diagnostics() {
+      return diagnostics
+    },
+    async waitForDiagnostics(request: { path: string }) {
+      const normalizedPath = Filesystem.normalizePath(
+        path.isAbsolute(request.path) ? request.path : path.resolve(input.directory, request.path),
+      )
+      log.info("waiting for diagnostics", { path: normalizedPath })
+      let unsub: () => void
+      let debounceTimer: ReturnType<typeof setTimeout> | undefined
+      return await withTimeout(
+        new Promise<void>((resolve) => {
+          unsub = Bus.subscribe(Event.Diagnostics, (event) => {
+            if (event.properties.path === normalizedPath && event.properties.serverID === result.serverID) {
+              // Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
+              if (debounceTimer) clearTimeout(debounceTimer)
+              debounceTimer = setTimeout(() => {
+                log.info("got diagnostics", { path: normalizedPath })
+                unsub?.()
+                resolve()
+              }, DIAGNOSTICS_DEBOUNCE_MS)
+            }
+          })
+        }),
+        3000,
+      )
+        .catch(() => {})
+        .finally(() => {
+          if (debounceTimer) clearTimeout(debounceTimer)
+          unsub?.()
+        })
+    },
+    async shutdown() {
+      l.info("shutting down")
+      connection.end()
+      connection.dispose()
+      await Process.stop(input.server.process)
+      l.info("shutdown")
+    },
+  }
+
+  l.info("initialized")
+
+  return result
+}

package/src/lsp/diagnostic.ts

@@ -0,0 +1,29 @@
+import * as LSPClient from "./client"
+
+const MAX_PER_FILE = 20
+
+export function pretty(diagnostic: LSPClient.Diagnostic) {
+  const severityMap = {
+    1: "ERROR",
+    2: "WARN",
+    3: "INFO",
+    4: "HINT",
+  }
+
+  const severity = severityMap[diagnostic.severity || 1]
+  const line = diagnostic.range.start.line + 1
+  const col = diagnostic.range.start.character + 1
+
+  return `${severity} [${line}:${col}] ${diagnostic.message}`
+}
+
+export function report(file: string, issues: LSPClient.Diagnostic[]) {
+  const errors = issues.filter((item) => item.severity === 1)
+  if (errors.length === 0) return ""
+  const limited = errors.slice(0, MAX_PER_FILE)
+  const more = errors.length - MAX_PER_FILE
+  const suffix = more > 0 ? `\n... and ${more} more` : ""
+  return `<diagnostics file="${file}">\n${limited.map(pretty).join("\n")}${suffix}\n</diagnostics>`
+}
+
+export * as Diagnostic from "./diagnostic"

package/src/lsp/index.ts

@@ -0,0 +1,3 @@
+export * as LSP from "./lsp"
+export * as LSPClient from "./client"
+export * as LSPServer from "./server"