@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

package/src/cli/cmd/providers.ts

@@ -0,0 +1,713 @@
+import { Auth } from "../../auth"
+import { AppRuntime } from "../../effect/app-runtime"
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { ModelsDev } from "../../provider"
+import { map, pipe, sortBy, values } from "remeda"
+import path from "path"
+import fs from "fs"
+import { pathToFileURL } from "url"
+import os from "os"
+import { Config } from "../../config"
+import { Global } from "../../global"
+import { Plugin } from "../../plugin"
+import { t } from "../i18n"
+import { Instance } from "../../project/instance"
+import type { Hooks } from "@sleepy-ai/plugin"
+import { Process } from "../../util"
+import { PROVIDER_PRIORITY } from "../../util/provider-priority"
+import { text } from "node:stream/consumers"
+import { Effect } from "effect"
+import * as readline from "readline"
+
+type PluginAuth = NonNullable<Hooks["auth"]>
+
+const put = (key: string, info: Auth.Info) =>
+  AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const auth = yield* Auth.Service
+      yield* auth.set(key, info)
+    }),
+  )
+
+async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string, methodName?: string): Promise<boolean> {
+  let index = 0
+  if (methodName) {
+    const match = plugin.auth.methods.findIndex((x) => x.label.toLowerCase() === methodName.toLowerCase())
+    if (match === -1) {
+      prompts.log.error(
+        `Unknown method "${methodName}" for ${provider}. Available: ${plugin.auth.methods.map((x) => x.label).join(", ")}`,
+      )
+      process.exit(1)
+    }
+    index = match
+  } else if (plugin.auth.methods.length > 1) {
+    const method = await prompts.select({
+      message: "Login method",
+      options: plugin.auth.methods.map((x, index) => ({
+        label: x.label,
+        value: index.toString(),
+      })),
+    })
+    if (prompts.isCancel(method)) throw new UI.CancelledError()
+    index = parseInt(method)
+  }
+  const method = plugin.auth.methods[index]
+
+  await new Promise((r) => setTimeout(r, 10))
+  const inputs: Record<string, string> = {}
+  if (method.prompts) {
+    for (const prompt of method.prompts) {
+      if (prompt.when) {
+        const value = inputs[prompt.when.key]
+        if (value === undefined) continue
+        const matches = prompt.when.op === "eq" ? value === prompt.when.value : value !== prompt.when.value
+        if (!matches) continue
+      }
+      if (prompt.condition && !prompt.condition(inputs)) continue
+      if (prompt.type === "select") {
+        const value = await prompts.select({
+          message: prompt.message,
+          options: prompt.options,
+        })
+        if (prompts.isCancel(value)) throw new UI.CancelledError()
+        inputs[prompt.key] = value
+      } else {
+        const value = await prompts.text({
+          message: prompt.message,
+          placeholder: prompt.placeholder,
+          validate: prompt.validate ? (v) => prompt.validate!(v ?? "") : undefined,
+        })
+        if (prompts.isCancel(value)) throw new UI.CancelledError()
+        inputs[prompt.key] = value
+      }
+    }
+  }
+
+  if (method.type === "oauth") {
+    const authorize = await method.authorize(inputs)
+
+    if (authorize.url) {
+      prompts.log.info("Go to: " + authorize.url)
+    }
+
+    if (authorize.method === "auto") {
+      if (authorize.instructions) {
+        prompts.log.info(authorize.instructions)
+      }
+      const spinner = prompts.spinner()
+      spinner.start("Waiting for authorization...")
+      const result = await authorize.callback()
+      if (result.type === "failed") {
+        spinner.stop("Failed to authorize", 1)
+      }
+      if (result.type === "success") {
+        const saveProvider = result.provider ?? provider
+        if ("refresh" in result) {
+          const { type: _, provider: __, refresh, access, expires, metadata: _m, ...extraFields } = result
+          await put(saveProvider, {
+            type: "oauth",
+            refresh,
+            access,
+            expires,
+            ...extraFields,
+          })
+        }
+        if ("key" in result) {
+          await put(saveProvider, {
+            type: "api",
+            key: result.key,
+            ...(result.metadata ? { metadata: result.metadata } : {}),
+          })
+        }
+        spinner.stop("Login successful")
+      }
+    }
+
+    if (authorize.method === "code") {
+      const code = await prompts.text({
+        message: "Paste the authorization code here: ",
+        validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+      })
+      if (prompts.isCancel(code)) throw new UI.CancelledError()
+      const result = await authorize.callback(code)
+      if (result.type === "failed") {
+        prompts.log.error("Failed to authorize")
+      }
+      if (result.type === "success") {
+        const saveProvider = result.provider ?? provider
+        if ("refresh" in result) {
+          const { type: _, provider: __, refresh, access, expires, metadata: _m, ...extraFields } = result
+          await put(saveProvider, {
+            type: "oauth",
+            refresh,
+            access,
+            expires,
+            ...extraFields,
+          })
+        }
+        if ("key" in result) {
+          await put(saveProvider, {
+            type: "api",
+            key: result.key,
+            ...(result.metadata ? { metadata: result.metadata } : {}),
+          })
+        }
+        prompts.log.success("Login successful")
+      }
+    }
+
+    prompts.outro("Done")
+    return true
+  }
+
+  if (method.type === "api") {
+    if (method.authorize) {
+      const key = await prompts.password({
+        message: "Enter your API key",
+        validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+      })
+      if (prompts.isCancel(key)) throw new UI.CancelledError()
+
+      const result = await method.authorize(inputs)
+      if (result.type === "failed") {
+        prompts.log.error("Failed to authorize")
+      }
+      if (result.type === "success") {
+        const saveProvider = result.provider ?? provider
+        await put(saveProvider, {
+          type: "api",
+          key: result.key ?? key,
+        })
+        prompts.log.success("Login successful")
+      }
+      prompts.outro("Done")
+      return true
+    }
+  }
+
+  return false
+}
+
+export function resolvePluginProviders(input: {
+  hooks: Hooks[]
+  existingProviders: Record<string, unknown>
+  disabled: Set<string>
+  enabled?: Set<string>
+  providerNames: Record<string, string | undefined>
+}): Array<{ id: string; name: string }> {
+  const seen = new Set<string>()
+  const result: Array<{ id: string; name: string }> = []
+
+  for (const hook of input.hooks) {
+    if (!hook.auth) continue
+    const id = hook.auth.provider
+    if (seen.has(id)) continue
+    seen.add(id)
+    if (Object.hasOwn(input.existingProviders, id)) continue
+    if (input.disabled.has(id)) continue
+    if (input.enabled && !input.enabled.has(id)) continue
+    result.push({
+      id,
+      name: input.providerNames[id] ?? id,
+    })
+  }
+
+  return result
+}
+
+// Optional login extension contributed by a local module under src/ext/. The
+// module declares which provider id/aliases it handles, how it appears in the
+// interactive menu, and the handler to run. Resolves to undefined when no such
+// module is present.
+type LoginExtension = {
+  id: string
+  aliases?: string[]
+  menu?: { label: string; hint?: string }
+  run: () => Promise<void>
+}
+
+function toLoginExtension(mod: Record<string, unknown> | undefined): LoginExtension | undefined {
+  const value = mod?.loginExtension
+  if (!value || typeof value !== "object") return undefined
+  const ext = value as Partial<LoginExtension>
+  if (typeof ext.id !== "string" || typeof ext.run !== "function") return undefined
+  return ext as LoginExtension
+}
+
+// Resolve the optional login extension. Prefers the generated src/ext/_manifest.ts
+// (a fixed import specifier resolves inside Bun single-file executables, where
+// filesystem scans do not); falls back to a directory scan for unbundled runs.
+async function loadLoginExtension(): Promise<LoginExtension | undefined> {
+  try {
+    // @ts-ignore generated manifest; may not exist at type-check time
+    const manifest = (await import("../../ext/_manifest")) as { modules?: Record<string, Record<string, unknown>> }
+    for (const mod of Object.values(manifest.modules ?? {})) {
+      const ext = toLoginExtension(mod)
+      if (ext) return ext
+    }
+  } catch {}
+  const extDir = path.join(import.meta.dir, "..", "..", "ext")
+  if (!fs.existsSync(extDir)) return undefined
+  for (const entry of fs.readdirSync(extDir).filter((f) => f.endsWith(".ts") && !f.endsWith(".d.ts"))) {
+    try {
+      const ext = toLoginExtension(await import(/* @vite-ignore */ pathToFileURL(path.join(extDir, entry)).href))
+      if (ext) return ext
+    } catch {}
+  }
+  return undefined
+}
+
+async function sleepyLogin() {
+  const hooks = await AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const plugin = yield* Plugin.Service
+      return yield* plugin.list()
+    }),
+  )
+  const sleepyHook = hooks.findLast((h) => h.auth?.provider === "sleepy")
+  if (!sleepyHook?.auth) {
+    prompts.log.error("Sleepy auth plugin not found")
+    return
+  }
+
+  const method = sleepyHook.auth.methods[0]
+  if (method.type !== "oauth") return
+
+  const authorize = await method.authorize()
+  if (authorize.method !== "auto") return
+
+  prompts.log.info(`Browser didn't open? Use the url below to sign in:\n${authorize.url}`)
+
+  const browserPromise = authorize.callback().catch(() => ({ type: "failed" as const }))
+
+  const MAX_RETRIES = 3
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    const raceResult = await raceCallbackAndStdin(browserPromise)
+
+    if (raceResult.source === "browser") {
+      if (raceResult.data.type === "success" && "key" in raceResult.data) {
+        await put("sleepy", {
+          type: "api",
+          key: raceResult.data.key,
+          ...(raceResult.data.metadata ? { metadata: raceResult.data.metadata } : {}),
+        })
+        prompts.log.success("Login successful")
+        prompts.outro("Done")
+        return
+      }
+      prompts.log.error("Login failed")
+      prompts.outro("Done")
+      return
+    }
+
+    const callbackResult = await authorize.callback(raceResult.input)
+    if (callbackResult.type === "success" && "key" in callbackResult) {
+      await put("sleepy", {
+        type: "api",
+        key: callbackResult.key,
+        ...(callbackResult.metadata ? { metadata: callbackResult.metadata } : {}),
+      })
+      prompts.log.success("Login successful")
+      prompts.outro("Done")
+      return
+    }
+
+    const remaining = MAX_RETRIES - attempt - 1
+    if (remaining > 0) {
+      prompts.log.error(t("cli.providers.sleepy_login.decrypt_retry", { remaining }))
+    } else {
+      prompts.log.error(t("cli.providers.sleepy_login.decrypt_exhausted"))
+    }
+  }
+}
+
+function raceCallbackAndStdin<T>(
+  browserPromise: Promise<T>,
+): Promise<{ source: "browser"; data: T } | { source: "paste"; input: string }> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+
+    let settled = false
+    const cleanup = () => {
+      if (settled) return
+      settled = true
+      rl.close()
+    }
+
+    browserPromise.then((data) => {
+      if (settled) return
+      cleanup()
+      process.stdout.write("\n")
+      resolve({ source: "browser", data })
+    })
+
+    rl.question("Paste code here if prompted > ", (answer) => {
+      if (settled) return
+      const trimmed = answer.trim()
+      if (trimmed.length > 0) {
+        cleanup()
+        resolve({ source: "paste", input: trimmed })
+      }
+    })
+  })
+}
+
+export const ProvidersCommand = cmd({
+  command: "providers",
+  aliases: ["auth"],
+  describe: "manage AI providers and credentials",
+  builder: (yargs) =>
+    yargs
+      .command(ProvidersListCommand)
+      .command(ProvidersLoginCommand)
+      .command(ProvidersLogoutCommand)
+      .command(ProvidersWhoamiCommand)
+      .demandCommand(),
+  async handler() {},
+})
+
+export const ProvidersListCommand = cmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list providers and credentials",
+  async handler(_args) {
+    UI.empty()
+    const authPath = path.join(Global.Path.data, "auth.json")
+    const homedir = os.homedir()
+    const displayPath = authPath.startsWith(homedir) ? authPath.replace(homedir, "~") : authPath
+    prompts.intro(`Credentials ${UI.Style.TEXT_DIM}${displayPath}`)
+    const results = await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        return Object.entries(yield* auth.all())
+      }),
+    )
+    const database = await ModelsDev.get()
+
+    for (const [providerID, result] of results) {
+      const name = database[providerID]?.name || providerID
+      prompts.log.info(`${name} ${UI.Style.TEXT_DIM}${result.type}`)
+    }
+
+    prompts.outro(`${results.length} credentials`)
+
+    const activeEnvVars: Array<{ provider: string; envVar: string }> = []
+
+    for (const [providerID, provider] of Object.entries(database)) {
+      for (const envVar of provider.env) {
+        if (process.env[envVar]) {
+          activeEnvVars.push({
+            provider: provider.name || providerID,
+            envVar,
+          })
+        }
+      }
+    }
+
+    if (activeEnvVars.length > 0) {
+      UI.empty()
+      prompts.intro("Environment")
+
+      for (const { provider, envVar } of activeEnvVars) {
+        prompts.log.info(`${provider} ${UI.Style.TEXT_DIM}${envVar}`)
+      }
+
+      prompts.outro(`${activeEnvVars.length} environment variable` + (activeEnvVars.length === 1 ? "" : "s"))
+    }
+  },
+})
+
+export const ProvidersLoginCommand = cmd({
+  command: "login [url]",
+  describe: "log in to a provider",
+  builder: (yargs) =>
+    yargs
+      .positional("url", {
+        describe: "sleepycode auth provider",
+        type: "string",
+      })
+      .option("provider", {
+        alias: ["p"],
+        describe: "provider id or name to log in to (skips provider selection)",
+        type: "string",
+      })
+      .option("method", {
+        alias: ["m"],
+        describe: "login method label (skips method selection)",
+        type: "string",
+      }),
+  async handler(args) {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Add credential")
+        if (args.url) {
+          const url = args.url.replace(/\/+$/, "")
+          const wellknown = (await fetch(`${url}/.well-known/opencode`).then((x) => x.json())) as {
+            auth: { command: string[]; env: string }
+          }
+          prompts.log.info(`Running \`${wellknown.auth.command.join(" ")}\``)
+          const proc = Process.spawn(wellknown.auth.command, {
+            stdout: "pipe",
+          })
+          if (!proc.stdout) {
+            prompts.log.error("Failed")
+            prompts.outro("Done")
+            return
+          }
+          const [exit, token] = await Promise.all([proc.exited, text(proc.stdout)])
+          if (exit !== 0) {
+            prompts.log.error("Failed")
+            prompts.outro("Done")
+            return
+          }
+          await put(url, {
+            type: "wellknown",
+            key: wellknown.auth.env,
+            token: token.trim(),
+          })
+          prompts.log.success("Logged into " + url)
+          prompts.outro("Done")
+          return
+        }
+        await ModelsDev.refresh(true).catch(() => {})
+
+        const config = await AppRuntime.runPromise(Config.Service.use((cfg) => cfg.get()))
+
+        const disabled = new Set(config.disabled_providers ?? [])
+        const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
+
+        const providers = await ModelsDev.get().then((x) => {
+          const filtered: Record<string, (typeof x)[string]> = {}
+          for (const [key, value] of Object.entries(x)) {
+            if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
+              filtered[key] = value
+            }
+          }
+          return filtered
+        })
+        const hooks = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const plugin = yield* Plugin.Service
+            return yield* plugin.list()
+          }),
+        )
+
+        const priority = PROVIDER_PRIORITY
+        const pluginProviders = resolvePluginProviders({
+          hooks,
+          existingProviders: providers,
+          disabled,
+          enabled,
+          providerNames: Object.fromEntries(Object.entries(config.provider ?? {}).map(([id, p]) => [id, p.name])),
+        })
+        const options = [
+          ...pipe(
+            providers,
+            values(),
+            sortBy(
+              (x) => priority[x.id] ?? 99,
+              (x) => x.name ?? x.id,
+            ),
+            map((x) => ({
+              label: x.name,
+              value: x.id,
+              hint: {
+                openai: "ChatGPT Plus/Pro or API key",
+              }[x.id],
+            })),
+          ),
+          ...pluginProviders.map((x) => ({
+            label: x.name,
+            value: x.id,
+            hint: "plugin",
+          })),
+        ]
+
+        const loginExt = await loadLoginExtension()
+        const loginExtIds = loginExt ? [loginExt.id, ...(loginExt.aliases ?? [])] : []
+        let provider: string
+        if (args.provider === "sleepy") {
+          await sleepyLogin()
+          return
+        } else if (loginExt && args.provider && loginExtIds.includes(args.provider)) {
+          await loginExt.run()
+          return
+        } else if (args.provider) {
+          const input = args.provider
+          const byID = options.find((x) => x.value === input)
+          const byName = options.find((x) => x.label.toLowerCase() === input.toLowerCase())
+          const match = byID ?? byName
+          if (!match) {
+            prompts.log.error(`Unknown provider "${input}"`)
+            process.exit(1)
+          }
+          provider = match.value
+        } else {
+          const choice = await prompts.select({
+            message: t("cli.providers.select"),
+            options: [
+              { label: "Sleepy", value: "sleepy", hint: t("cli.providers.sleepy.recommended_hint") },
+              ...(loginExt?.menu
+                ? [{ label: loginExt.menu.label, value: loginExt.id, hint: loginExt.menu.hint }]
+                : []),
+              { label: t("cli.providers.other"), value: "__other__" },
+            ],
+          })
+          if (prompts.isCancel(choice)) throw new UI.CancelledError()
+
+          if (choice === "sleepy") {
+            await sleepyLogin()
+            return
+          }
+
+          if (loginExt && choice === loginExt.id) {
+            await loginExt.run()
+            return
+          }
+
+          const selected = await prompts.autocomplete({
+            message: t("cli.providers.select"),
+            maxItems: 8,
+            options: [
+              ...options,
+              {
+                value: "other",
+                label: "Other",
+              },
+            ],
+          })
+          if (prompts.isCancel(selected)) throw new UI.CancelledError()
+          provider = selected as string
+        }
+
+        const plugin = hooks.findLast((x) => x.auth?.provider === provider)
+        if (plugin && plugin.auth) {
+          const handled = await handlePluginAuth({ auth: plugin.auth }, provider, args.method)
+          if (handled) return
+        }
+
+        if (provider === "other") {
+          const custom = await prompts.text({
+            message: "Enter provider id",
+            validate: (x) => (x && x.match(/^[0-9a-z-]+$/) ? undefined : "a-z, 0-9 and hyphens only"),
+          })
+          if (prompts.isCancel(custom)) throw new UI.CancelledError()
+          provider = custom.replace(/^@ai-sdk\//, "")
+
+          const customPlugin = hooks.findLast((x) => x.auth?.provider === provider)
+          if (customPlugin && customPlugin.auth) {
+            const handled = await handlePluginAuth({ auth: customPlugin.auth }, provider, args.method)
+            if (handled) return
+          }
+
+          prompts.log.warn(
+            `This only stores a credential for ${provider} - you will need configure it in sleepycode.json, check the docs for examples.`,
+          )
+        }
+
+        if (provider === "amazon-bedrock") {
+          prompts.log.info(
+            "Amazon Bedrock authentication priority:\n" +
+              "  1. Bearer token (AWS_BEARER_TOKEN_BEDROCK or /connect)\n" +
+              "  2. AWS credential chain (profile, access keys, IAM roles, EKS IRSA)\n\n" +
+              "Configure via sleepycode.json options (profile, region, endpoint) or\n" +
+              "AWS environment variables (AWS_PROFILE, AWS_REGION, AWS_ACCESS_KEY_ID, AWS_WEB_IDENTITY_TOKEN_FILE).",
+          )
+        }
+
+        if (provider === "opencode") {
+          prompts.log.info("Create an api key at https://opencode.ai/auth")
+        }
+
+        if (provider === "vercel") {
+          prompts.log.info("You can create an api key at https://vercel.link/ai-gateway-token")
+        }
+
+        if (["cloudflare", "cloudflare-ai-gateway"].includes(provider)) {
+          prompts.log.info(
+            "Cloudflare AI Gateway can be configured with CLOUDFLARE_GATEWAY_ID, CLOUDFLARE_ACCOUNT_ID, and CLOUDFLARE_API_TOKEN environment variables. Read more: https://opencode.ai/docs/providers/#cloudflare-ai-gateway",
+          )
+        }
+
+        const key = await prompts.password({
+          message: "Enter your API key",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        })
+        if (prompts.isCancel(key)) throw new UI.CancelledError()
+        await put(provider, {
+          type: "api",
+          key,
+        })
+
+        prompts.outro("Done")
+      },
+    })
+  },
+})
+
+export const ProvidersLogoutCommand = cmd({
+  command: "logout",
+  describe: "log out from a configured provider",
+  async handler(_args) {
+    UI.empty()
+    const credentials: Array<[string, Auth.Info]> = await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        return Object.entries(yield* auth.all())
+      }),
+    )
+    prompts.intro("Remove credential")
+    if (credentials.length === 0) {
+      prompts.log.error("No credentials found")
+      return
+    }
+    const database = await ModelsDev.get()
+    const selected = await prompts.select({
+      message: "Select provider",
+      options: credentials.map(([key, value]) => ({
+        label: (database[key]?.name || key) + UI.Style.TEXT_DIM + " (" + value.type + ")",
+        value: key,
+      })),
+    })
+    if (prompts.isCancel(selected)) throw new UI.CancelledError()
+    const providerID = selected as string
+    await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        yield* auth.remove(providerID)
+      }),
+    )
+    prompts.outro("Logout successful")
+  },
+})
+
+export const ProvidersWhoamiCommand = cmd({
+  command: "whoami",
+  describe: "show current logged-in user info",
+  async handler(_args) {
+    UI.empty()
+    prompts.intro("Current user")
+    const info = await AppRuntime.runPromise(
+      Effect.gen(function* () {
+        const auth = yield* Auth.Service
+        return yield* auth.get("sleepy")
+      }),
+    )
+    if (!info) {
+      prompts.log.error("Not logged in. Run `sleepy auth login` to log in.")
+      return
+    }
+    if (info.type === "api" && info.metadata) {
+      prompts.log.info(`Provider: Sleepy`)
+      prompts.log.info(`User ID: ${info.metadata.uid ?? "unknown"}`)
+    } else {
+      prompts.log.info(`Provider: Sleepy`)
+      prompts.log.info(`Type: ${info.type}`)
+    }
+    prompts.outro("")
+  },
+})