easc-cli 1.1.28

package/src/cli/cmd/agent.ts

@@ -0,0 +1,257 @@
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { Global } from "../../global"
+import { Agent } from "../../agent/agent"
+import { Provider } from "../../provider/provider"
+import path from "path"
+import fs from "fs/promises"
+import matter from "gray-matter"
+import { Instance } from "../../project/instance"
+import { EOL } from "os"
+import type { Argv } from "yargs"
+
+type AgentMode = "all" | "primary" | "subagent"
+
+const AVAILABLE_TOOLS = [
+    "bash",
+    "read",
+    "write",
+    "edit",
+    "list",
+    "glob",
+    "grep",
+    "webfetch",
+    "task",
+    "todowrite",
+    "todoread",
+]
+
+const AgentCreateCommand = cmd({
+    command: "create",
+    describe: "create a new agent",
+    builder: (yargs: Argv) =>
+        yargs
+            .option("path", {
+                type: "string",
+                describe: "directory path to generate the agent file",
+            })
+            .option("description", {
+                type: "string",
+                describe: "what the agent should do",
+            })
+            .option("mode", {
+                type: "string",
+                describe: "agent mode",
+                choices: ["all", "primary", "subagent"] as const,
+            })
+            .option("tools", {
+                type: "string",
+                describe: `comma-separated list of tools to enable (default: all). Available: "${AVAILABLE_TOOLS.join(", ")}"`,
+            })
+            .option("model", {
+                type: "string",
+                alias: ["m"],
+                describe: "model to use in the format of provider/model",
+            }),
+    async handler(args) {
+        await Instance.provide({
+            directory: process.cwd(),
+            async fn() {
+                const cliPath = args.path
+                const cliDescription = args.description
+                const cliMode = args.mode as AgentMode | undefined
+                const cliTools = args.tools
+
+                const isFullyNonInteractive = cliPath && cliDescription && cliMode && cliTools !== undefined
+
+                if (!isFullyNonInteractive) {
+                    UI.empty()
+                    prompts.intro("Create agent")
+                }
+
+                const project = Instance.project
+
+                // Determine scope/path
+                let targetPath: string
+                if (cliPath) {
+                    targetPath = path.join(cliPath, "agent")
+                } else {
+                    let scope: "global" | "project" = "global"
+                    if (project.vcs === "git") {
+                        const scopeResult = await prompts.select({
+                            message: "Location",
+                            options: [
+                                {
+                                    label: "Current project",
+                                    value: "project" as const,
+                                    hint: Instance.worktree,
+                                },
+                                {
+                                    label: "Global",
+                                    value: "global" as const,
+                                    hint: Global.Path.config,
+                                },
+                            ],
+                        })
+                        if (prompts.isCancel(scopeResult)) throw new UI.CancelledError()
+                        scope = scopeResult
+                    }
+                    targetPath = path.join(
+                        scope === "global" ? Global.Path.config : path.join(Instance.worktree, ".easc"),
+                        "agent",
+                    )
+                }
+
+                // Get description
+                let description: string
+                if (cliDescription) {
+                    description = cliDescription
+                } else {
+                    const query = await prompts.text({
+                        message: "Description",
+                        placeholder: "What should this agent do?",
+                        validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+                    })
+                    if (prompts.isCancel(query)) throw new UI.CancelledError()
+                    description = query
+                }
+
+                // Generate agent
+                const spinner = prompts.spinner()
+                spinner.start("Generating agent configuration...")
+                const model = args.model ? Provider.parseModel(args.model) : undefined
+                const generated = await Agent.generate({ description, model }).catch((error) => {
+                    spinner.stop(`LLM failed to generate agent: ${error.message}`, 1)
+                    if (isFullyNonInteractive) process.exit(1)
+                    throw new UI.CancelledError()
+                })
+                spinner.stop(`Agent ${generated.identifier} generated`)
+
+                // Select tools
+                let selectedTools: string[]
+                if (cliTools !== undefined) {
+                    selectedTools = cliTools ? cliTools.split(",").map((t) => t.trim()) : AVAILABLE_TOOLS
+                } else {
+                    const result = await prompts.multiselect({
+                        message: "Select tools to enable (Space to toggle)",
+                        options: AVAILABLE_TOOLS.map((tool) => ({
+                            label: tool,
+                            value: tool,
+                        })),
+                        initialValues: AVAILABLE_TOOLS,
+                    })
+                    if (prompts.isCancel(result)) throw new UI.CancelledError()
+                    selectedTools = result
+                }
+
+                // Get mode
+                let mode: AgentMode
+                if (cliMode) {
+                    mode = cliMode
+                } else {
+                    const modeResult = await prompts.select({
+                        message: "Agent mode",
+                        options: [
+                            {
+                                label: "All",
+                                value: "all" as const,
+                                hint: "Can function in both primary and subagent roles",
+                            },
+                            {
+                                label: "Primary",
+                                value: "primary" as const,
+                                hint: "Acts as a primary/main agent",
+                            },
+                            {
+                                label: "Subagent",
+                                value: "subagent" as const,
+                                hint: "Can be used as a subagent by other agents",
+                            },
+                        ],
+                        initialValue: "all" as const,
+                    })
+                    if (prompts.isCancel(modeResult)) throw new UI.CancelledError()
+                    mode = modeResult
+                }
+
+                // Build tools config
+                const tools: Record<string, boolean> = {}
+                for (const tool of AVAILABLE_TOOLS) {
+                    if (!selectedTools.includes(tool)) {
+                        tools[tool] = false
+                    }
+                }
+
+                // Build frontmatter
+                const frontmatter: {
+                    description: string
+                    mode: AgentMode
+                    tools?: Record<string, boolean>
+                } = {
+                    description: generated.whenToUse,
+                    mode,
+                }
+                if (Object.keys(tools).length > 0) {
+                    frontmatter.tools = tools
+                }
+
+                // Write file
+                const content = matter.stringify(generated.systemPrompt, frontmatter)
+                const filePath = path.join(targetPath, `${generated.identifier}.md`)
+
+                await fs.mkdir(targetPath, { recursive: true })
+
+                const file = Bun.file(filePath)
+                if (await file.exists()) {
+                    if (isFullyNonInteractive) {
+                        console.error(`Error: Agent file already exists: ${filePath}`)
+                        process.exit(1)
+                    }
+                    prompts.log.error(`Agent file already exists: ${filePath}`)
+                    throw new UI.CancelledError()
+                }
+
+                await Bun.write(filePath, content)
+
+                if (isFullyNonInteractive) {
+                    console.log(filePath)
+                } else {
+                    prompts.log.success(`Agent created: ${filePath}`)
+                    prompts.outro("Done")
+                }
+            },
+        })
+    },
+})
+
+const AgentListCommand = cmd({
+    command: "list",
+    describe: "list all available agents",
+    async handler() {
+        await Instance.provide({
+            directory: process.cwd(),
+            async fn() {
+                const agents = await Agent.list()
+                const sortedAgents = agents.sort((a, b) => {
+                    if (a.native !== b.native) {
+                        return a.native ? -1 : 1
+                    }
+                    return a.name.localeCompare(b.name)
+                })
+
+                for (const agent of sortedAgents) {
+                    process.stdout.write(`${agent.name} (${agent.mode})` + EOL)
+                    process.stdout.write(`  ${JSON.stringify(agent.permission, null, 2)}` + EOL)
+                }
+            },
+        })
+    },
+})
+
+export const AgentCommand = cmd({
+    command: "agent",
+    describe: "manage agents",
+    builder: (yargs) => yargs.command(AgentCreateCommand).command(AgentListCommand).demandCommand(),
+    async handler() { },
+})

package/src/cli/cmd/auth.ts

@@ -0,0 +1,427 @@
+import { Auth } from "../../auth"
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { ModelsDev } from "../../provider/models"
+import { map, pipe, sortBy, values } from "remeda"
+import path from "path"
+import os from "os"
+import { Config } from "../../config/config"
+import { Global } from "../../global"
+import { Plugin } from "../../plugin"
+import { Instance } from "../../project/instance"
+import type { Hooks } from "@eliseart.ai/plugin"
+import { EliseArtAuth } from "../../auth/eliseart"
+
+type PluginAuth = NonNullable<Hooks["auth"]>
+
+/**
+ * Handle plugin-based authentication flow.
+ * Returns true if auth was handled, false if it should fall through to default handling.
+ */
+async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string): Promise<boolean> {
+  let index = 0
+  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]
+
+  // Handle prompts for all auth types
+  await Bun.sleep(10)
+  const inputs: Record<string, string> = {}
+  if (method.prompts) {
+    for (const prompt of method.prompts) {
+      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, ...extraFields } = result
+          await Auth.set(saveProvider, {
+            type: "oauth",
+            refresh,
+            access,
+            expires,
+            ...extraFields,
+          })
+        }
+        if ("key" in result) {
+          await Auth.set(saveProvider, {
+            type: "api",
+            key: result.key,
+          })
+        }
+        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, ...extraFields } = result
+          await Auth.set(saveProvider, {
+            type: "oauth",
+            refresh,
+            access,
+            expires,
+            ...extraFields,
+          })
+        }
+        if ("key" in result) {
+          await Auth.set(saveProvider, {
+            type: "api",
+            key: result.key,
+          })
+        }
+        prompts.log.success("Login successful")
+      }
+    }
+
+    prompts.outro("Done")
+    return true
+  }
+
+  if (method.type === "api") {
+    if (method.authorize) {
+      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 Auth.set(saveProvider, {
+          type: "api",
+          key: result.key,
+        })
+        prompts.log.success("Login successful")
+      }
+      prompts.outro("Done")
+      return true
+    }
+  }
+
+  return false
+}
+
+export const AuthCommand = cmd({
+  command: "auth",
+  describe: "manage credentials",
+  builder: (yargs) =>
+    yargs.command(AuthLoginCommand).command(AuthLogoutCommand).command(AuthListCommand).demandCommand(),
+  async handler() { },
+})
+
+export const AuthListCommand = cmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list providers",
+  async handler() {
+    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 = Object.entries(await 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`)
+
+    // Environment variables section
+    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 AuthLoginCommand = cmd({
+  command: "login [url]",
+  describe: "log in to a provider",
+  builder: (yargs) =>
+    yargs.positional("url", {
+      describe: "opencode auth provider",
+      type: "string",
+    }),
+  async handler(args) {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        prompts.intro("Add credential")
+        if (args.url && (args.url.startsWith("http://") || args.url.startsWith("https://"))) {
+          const wellknown = await fetch(`${args.url}/.well-known/opencode`).then((x) => x.json() as any)
+          prompts.log.info(`Running \`${wellknown.auth.command.join(" ")}\``)
+          const proc = Bun.spawn({
+            cmd: wellknown.auth.command,
+            stdout: "pipe",
+          })
+          const exit = await proc.exited
+          if (exit !== 0) {
+            prompts.log.error("Failed")
+            prompts.outro("Done")
+            return
+          }
+          const token = await new Response(proc.stdout).text()
+          await Auth.set(args.url, {
+            type: "wellknown",
+            key: wellknown.auth.env,
+            token: token.trim(),
+          })
+          prompts.log.success("Logged into " + args.url)
+          prompts.outro("Done")
+          return
+        }
+        await ModelsDev.refresh().catch(() => { })
+
+        const config = await Config.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 priority: Record<string, number> = {
+          eliseart: 0,
+          opencode: 1,
+          anthropic: 2,
+          "github-copilot": 3,
+          openai: 4,
+          google: 5,
+          openrouter: 6,
+          vercel: 7,
+        }
+        let providerInput: string | symbol | undefined = args.url
+        if (!providerInput) {
+          providerInput = await prompts.autocomplete({
+            message: "Select provider",
+            maxItems: 8,
+            options: [
+              ...pipe(
+                providers,
+                values(),
+                sortBy(
+                  (x) => priority[x.id] ?? 99,
+                  (x) => x.name ?? x.id,
+                ),
+                map((x) => ({
+                  label: x.name,
+                  value: x.id,
+                  hint: {
+                    opencode: "recommended",
+                    anthropic: "Claude Max or API key",
+                    openai: "ChatGPT Plus/Pro or API key",
+                  }[x.id],
+                })),
+              ),
+              {
+                value: "other",
+                label: "Other",
+              },
+            ],
+          })
+        }
+
+        if (prompts.isCancel(providerInput)) throw new UI.CancelledError()
+        let provider = providerInput as string
+
+        if (provider === "eliseart") {
+          prompts.log.info("To login, visit: https://elise-art.web.app/cli-auth")
+          const token = await prompts.text({
+            message: "Paste your access token",
+            validate: (x) => (x && x.length > 20 ? undefined : "Invalid token"),
+          })
+          if (prompts.isCancel(token)) throw new UI.CancelledError()
+
+          const spinner = prompts.spinner()
+          spinner.start("Verifying token...")
+          try {
+            await EliseArtAuth.loginWithToken(token as string)
+            spinner.stop("Login successful")
+          } catch (e: any) {
+            spinner.stop("Login failed: " + e.message, 1)
+          }
+          prompts.outro("Done")
+          return
+        }
+
+        const plugin = await Plugin.list().then((x) => x.find((x) => x.auth?.provider === provider))
+        if (plugin && plugin.auth) {
+          const handled = await handlePluginAuth({ auth: plugin.auth }, provider)
+          if (handled) return
+        }
+
+        if (provider === "other") {
+          const result = 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(result)) throw new UI.CancelledError()
+          provider = result as string
+          provider = provider.replace(/^@ai-sdk\//, "")
+          if (prompts.isCancel(provider)) throw new UI.CancelledError()
+
+          // Check if a plugin provides auth for this custom provider
+          const customPlugin = await Plugin.list().then((x) => x.find((x) => x.auth?.provider === provider))
+          if (customPlugin && customPlugin.auth) {
+            const handled = await handlePluginAuth({ auth: customPlugin.auth }, provider)
+            if (handled) return
+          }
+
+          prompts.log.warn(
+            `This only stores a credential for ${provider} - you will need configure it in opencode.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 opencode.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://eliseart.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://eliseart.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 Auth.set(provider, {
+          type: "api",
+          key,
+        })
+
+        prompts.outro("Done")
+      },
+    })
+  },
+})
+
+export const AuthLogoutCommand = cmd({
+  command: "logout",
+  describe: "log out from a configured provider",
+  async handler() {
+    UI.empty()
+    const credentials = await Auth.all().then((x) => Object.entries(x))
+    prompts.intro("Remove credential")
+    if (credentials.length === 0) {
+      prompts.log.error("No credentials found")
+      return
+    }
+    const database = await ModelsDev.get()
+    const providerID = 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(providerID)) throw new UI.CancelledError()
+    await Auth.remove(providerID)
+    prompts.outro("Logout successful")
+  },
+})

package/src/cli/cmd/cmd.ts

@@ -0,0 +1,7 @@
+import type { CommandModule } from "yargs"
+
+type WithDoubleDash<T> = T & { "--"?: string[] }
+
+export function cmd<T, U>(input: CommandModule<T, WithDoubleDash<U>>) {
+  return input
+}