@epoch-ai/cli 2.2.4 → 2.2.5

package/src/cli/cmd/account.ts

@@ -1,257 +0,0 @@
-import { cmd } from "./cmd"
-import { Duration, Effect, Match, Option } from "effect"
-import { UI } from "../ui"
-import { AccountID, Account, OrgID, PollExpired, type PollResult } from "@/account"
-import { type AccountError } from "@/account/schema"
-import * as Prompt from "../effect/prompt"
-import open from "open"
-
-const openBrowser = (url: string) => Effect.promise(() => open(url).catch(() => undefined))
-
-const println = (msg: string) => Effect.sync(() => UI.println(msg))
-
-const dim = (value: string) => UI.Style.TEXT_DIM + value + UI.Style.TEXT_NORMAL
-
-const activeSuffix = (isActive: boolean) => (isActive ? dim(" (active)") : "")
-
-export const formatAccountLabel = (account: { email: string; url: string }, isActive: boolean) =>
-  `${account.email} ${dim(account.url)}${activeSuffix(isActive)}`
-
-const formatOrgChoiceLabel = (account: { email: string }, org: { name: string }, isActive: boolean) =>
-  `${org.name} (${account.email})${activeSuffix(isActive)}`
-
-export const formatOrgLine = (
-  account: { email: string; url: string },
-  org: { id: string; name: string },
-  isActive: boolean,
-) => {
-  const dot = isActive ? UI.Style.TEXT_SUCCESS + "●" + UI.Style.TEXT_NORMAL : " "
-  const name = isActive ? UI.Style.TEXT_HIGHLIGHT_BOLD + org.name + UI.Style.TEXT_NORMAL : org.name
-  return `  ${dot} ${name}  ${dim(account.email)}  ${dim(account.url)}  ${dim(org.id)}`
-}
-
-const isActiveOrgChoice = (
-  active: Option.Option<{ id: AccountID; active_org_id: OrgID | null }>,
-  choice: { accountID: AccountID; orgID: OrgID },
-) => Option.isSome(active) && active.value.id === choice.accountID && active.value.active_org_id === choice.orgID
-
-const loginEffect = Effect.fn("login")(function* (url: string) {
-  const service = yield* Account.Service
-
-  yield* Prompt.intro("Log in")
-  const login = yield* service.login(url)
-
-  yield* Prompt.log.info("Go to: " + login.url)
-  yield* Prompt.log.info("Enter code: " + login.user)
-  yield* openBrowser(login.url)
-
-  const s = Prompt.spinner()
-  yield* s.start("Waiting for authorization...")
-
-  const poll = (wait: Duration.Duration): Effect.Effect<PollResult, AccountError> =>
-    Effect.gen(function* () {
-      yield* Effect.sleep(wait)
-      const result = yield* service.poll(login)
-      if (result._tag === "PollPending") return yield* poll(wait)
-      if (result._tag === "PollSlow") return yield* poll(Duration.sum(wait, Duration.seconds(5)))
-      return result
-    })
-
-  const result = yield* poll(login.interval).pipe(
-    Effect.timeout(login.expiry),
-    Effect.catchTag("TimeoutError", () => Effect.succeed(new PollExpired())),
-  )
-
-  yield* Match.valueTags(result, {
-    PollSuccess: (r) =>
-      Effect.gen(function* () {
-        yield* s.stop("Logged in as " + r.email)
-        yield* Prompt.outro("Done")
-      }),
-    PollExpired: () => s.stop("Device code expired", 1),
-    PollDenied: () => s.stop("Authorization denied", 1),
-    PollError: (r) => s.stop("Error: " + String(r.cause), 1),
-    PollPending: () => s.stop("Unexpected state", 1),
-    PollSlow: () => s.stop("Unexpected state", 1),
-  })
-})
-
-const logoutEffect = Effect.fn("logout")(function* (email?: string) {
-  const service = yield* Account.Service
-  const accounts = yield* service.list()
-  if (accounts.length === 0) return yield* println("Not logged in")
-
-  if (email) {
-    const match = accounts.find((a) => a.email === email)
-    if (!match) return yield* println("Account not found: " + email)
-    yield* service.remove(match.id)
-    yield* Prompt.outro("Logged out from " + email)
-    return
-  }
-
-  const active = yield* service.active()
-  const activeID = Option.map(active, (a) => a.id)
-
-  yield* Prompt.intro("Log out")
-
-  const opts = accounts.map((a) => {
-    const isActive = Option.isSome(activeID) && activeID.value === a.id
-    return {
-      value: a,
-      label: formatAccountLabel(a, isActive),
-    }
-  })
-
-  const selected = yield* Prompt.select({ message: "Select account to log out", options: opts })
-  if (Option.isNone(selected)) return
-
-  yield* service.remove(selected.value.id)
-  yield* Prompt.outro("Logged out from " + selected.value.email)
-})
-
-interface OrgChoice {
-  orgID: OrgID
-  accountID: AccountID
-  label: string
-}
-
-const switchEffect = Effect.fn("switch")(function* () {
-  const service = yield* Account.Service
-
-  const groups = yield* service.orgsByAccount()
-  if (groups.length === 0) return yield* println("Not logged in")
-
-  const active = yield* service.active()
-
-  const opts = groups.flatMap((group) =>
-    group.orgs.map((org) => {
-      const isActive = isActiveOrgChoice(active, { accountID: group.account.id, orgID: org.id })
-      return {
-        value: { orgID: org.id, accountID: group.account.id, label: org.name },
-        label: formatOrgChoiceLabel(group.account, org, isActive),
-      }
-    }),
-  )
-  if (opts.length === 0) return yield* println("No orgs found")
-
-  yield* Prompt.intro("Switch org")
-
-  const selected = yield* Prompt.select<OrgChoice>({ message: "Select org", options: opts })
-  if (Option.isNone(selected)) return
-
-  const choice = selected.value
-  yield* service.use(choice.accountID, Option.some(choice.orgID))
-  yield* Prompt.outro("Switched to " + choice.label)
-})
-
-const orgsEffect = Effect.fn("orgs")(function* () {
-  const service = yield* Account.Service
-
-  const groups = yield* service.orgsByAccount()
-  if (groups.length === 0) return yield* println("No accounts found")
-  if (!groups.some((group) => group.orgs.length > 0)) return yield* println("No orgs found")
-
-  const active = yield* service.active()
-
-  for (const group of groups) {
-    for (const org of group.orgs) {
-      const isActive = isActiveOrgChoice(active, { accountID: group.account.id, orgID: org.id })
-      yield* println(formatOrgLine(group.account, org, isActive))
-    }
-  }
-})
-
-const openEffect = Effect.fn("open")(function* () {
-  const service = yield* Account.Service
-  const active = yield* service.active()
-  if (Option.isNone(active)) return yield* println("No active account")
-
-  const url = active.value.url
-  yield* openBrowser(url)
-  yield* Prompt.outro("Opened " + url)
-})
-
-export const LoginCommand = cmd({
-  command: "login <url>",
-  describe: false,
-  builder: (yargs) =>
-    yargs.positional("url", {
-      describe: "server URL",
-      type: "string",
-      demandOption: true,
-    }),
-  async handler(args) {
-    UI.empty()
-    await Account.runPromise((_svc) => loginEffect(args.url))
-  },
-})
-
-export const LogoutCommand = cmd({
-  command: "logout [email]",
-  describe: false,
-  builder: (yargs) =>
-    yargs.positional("email", {
-      describe: "account email to log out from",
-      type: "string",
-    }),
-  async handler(args) {
-    UI.empty()
-    await Account.runPromise((_svc) => logoutEffect(args.email))
-  },
-})
-
-export const SwitchCommand = cmd({
-  command: "switch",
-  describe: false,
-  async handler() {
-    UI.empty()
-    await Account.runPromise((_svc) => switchEffect())
-  },
-})
-
-export const OrgsCommand = cmd({
-  command: "orgs",
-  describe: false,
-  async handler() {
-    UI.empty()
-    await Account.runPromise((_svc) => orgsEffect())
-  },
-})
-
-export const OpenCommand = cmd({
-  command: "open",
-  describe: false,
-  async handler() {
-    UI.empty()
-    await Account.runPromise((_svc) => openEffect())
-  },
-})
-
-export const ConsoleCommand = cmd({
-  command: "console",
-  describe: false,
-  builder: (yargs) =>
-    yargs
-      .command({
-        ...LoginCommand,
-        describe: "log in to console",
-      })
-      .command({
-        ...LogoutCommand,
-        describe: "log out from console",
-      })
-      .command({
-        ...SwitchCommand,
-        describe: "switch active org",
-      })
-      .command({
-        ...OrgsCommand,
-        describe: "list orgs",
-      })
-      .command({
-        ...OpenCommand,
-        describe: "open active console account",
-      })
-      .demandCommand(),
-  async handler() {},
-})

package/src/cli/cmd/acp.ts

@@ -1,70 +0,0 @@
-import { Log } from "@/util/log"
-import { bootstrap } from "../bootstrap"
-import { cmd } from "./cmd"
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
-import { ACP } from "@/acp/agent"
-import { Server } from "@/server/server"
-import { createEpochClient } from "@epoch-ai/sdk/v2"
-import { withNetworkOptions, resolveNetworkOptions } from "../network"
-
-const log = Log.create({ service: "acp-command" })
-
-export const AcpCommand = cmd({
-  command: "acp",
-  describe: "start ACP (Agent Client Protocol) server",
-  builder: (yargs) => {
-    return withNetworkOptions(yargs).option("cwd", {
-      describe: "working directory",
-      type: "string",
-      default: process.cwd(),
-    })
-  },
-  handler: async (args) => {
-    process.env.EPOCHCLI_CLIENT = "acp"
-    await bootstrap(process.cwd(), async () => {
-      const opts = await resolveNetworkOptions(args)
-      const server = await Server.listen(opts)
-
-      const sdk = createEpochClient({
-        baseUrl: `http://${server.hostname}:${server.port}`,
-      })
-
-      const input = new WritableStream<Uint8Array>({
-        write(chunk) {
-          return new Promise<void>((resolve, reject) => {
-            process.stdout.write(chunk, (err) => {
-              if (err) {
-                reject(err)
-              } else {
-                resolve()
-              }
-            })
-          })
-        },
-      })
-      const output = new ReadableStream<Uint8Array>({
-        start(controller) {
-          process.stdin.on("data", (chunk: Buffer) => {
-            controller.enqueue(new Uint8Array(chunk))
-          })
-          process.stdin.on("end", () => controller.close())
-          process.stdin.on("error", (err) => controller.error(err))
-        },
-      })
-
-      const stream = ndJsonStream(input, output)
-      const agent = await ACP.init({ sdk })
-
-      new AgentSideConnection((conn) => {
-        return agent.create(conn, { sdk })
-      }, stream)
-
-      log.info("setup connection")
-      process.stdin.resume()
-      await new Promise((resolve, reject) => {
-        process.stdin.on("end", resolve)
-        process.stdin.on("error", reject)
-      })
-    })
-  },
-})

package/src/cli/cmd/agent.ts

@@ -1,245 +0,0 @@
-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 { Filesystem } from "../../util/filesystem"
-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"]
-
-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, ".epochcli"),
-            "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 })
-
-        if (await Filesystem.exists(filePath)) {
-          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 Filesystem.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/cmd.ts

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

package/src/cli/cmd/db.ts

@@ -1,119 +0,0 @@
-import type { Argv } from "yargs"
-import { spawn } from "child_process"
-import { Database } from "../../storage/db"
-import { Database as BunDatabase } from "bun:sqlite"
-import { UI } from "../ui"
-import { cmd } from "./cmd"
-import { JsonMigration } from "../../storage/json-migration"
-import { EOL } from "os"
-import { errorMessage } from "../../util/error"
-
-const QueryCommand = cmd({
-  command: "$0 [query]",
-  describe: "open an interactive sqlite3 shell or run a query",
-  builder: (yargs: Argv) => {
-    return yargs
-      .positional("query", {
-        type: "string",
-        describe: "SQL query to execute",
-      })
-      .option("format", {
-        type: "string",
-        choices: ["json", "tsv"],
-        default: "tsv",
-        describe: "Output format",
-      })
-  },
-  handler: async (args: { query?: string; format: string }) => {
-    const query = args.query as string | undefined
-    if (query) {
-      const db = new BunDatabase(Database.Path, { readonly: true })
-      try {
-        const result = db.query(query).all() as Record<string, unknown>[]
-        if (args.format === "json") {
-          console.log(JSON.stringify(result, null, 2))
-        } else if (result.length > 0) {
-          const keys = Object.keys(result[0])
-          console.log(keys.join("\t"))
-          for (const row of result) {
-            console.log(keys.map((k) => row[k]).join("\t"))
-          }
-        }
-      } catch (err) {
-        UI.error(errorMessage(err))
-        process.exit(1)
-      }
-      db.close()
-      return
-    }
-    const child = spawn("sqlite3", [Database.Path], {
-      stdio: "inherit",
-    })
-    await new Promise((resolve) => child.on("close", resolve))
-  },
-})
-
-const PathCommand = cmd({
-  command: "path",
-  describe: "print the database path",
-  handler: () => {
-    console.log(Database.Path)
-  },
-})
-
-const MigrateCommand = cmd({
-  command: "migrate",
-  describe: "migrate JSON data to SQLite (merges with existing data)",
-  handler: async () => {
-    const sqlite = new BunDatabase(Database.Path)
-    const tty = process.stderr.isTTY
-    const width = 36
-    const orange = "\x1b[38;5;214m"
-    const muted = "\x1b[0;2m"
-    const reset = "\x1b[0m"
-    let last = -1
-    if (tty) process.stderr.write("\x1b[?25l")
-    try {
-      const stats = await JsonMigration.run(sqlite, {
-        progress: (event) => {
-          const percent = Math.floor((event.current / event.total) * 100)
-          if (percent === last) return
-          last = percent
-          if (tty) {
-            const fill = Math.round((percent / 100) * width)
-            const bar = `${"■".repeat(fill)}${"･".repeat(width - fill)}`
-            process.stderr.write(
-              `\r${orange}${bar} ${percent.toString().padStart(3)}%${reset} ${muted}${event.current}/${event.total}${reset} `,
-            )
-          } else {
-            process.stderr.write(`sqlite-migration:${percent}${EOL}`)
-          }
-        },
-      })
-      if (tty) process.stderr.write("\n")
-      if (tty) process.stderr.write("\x1b[?25h")
-      else process.stderr.write(`sqlite-migration:done${EOL}`)
-      UI.println(
-        `Migration complete: ${stats.projects} projects, ${stats.sessions} sessions, ${stats.messages} messages`,
-      )
-      if (stats.errors.length > 0) {
-        UI.println(`${stats.errors.length} errors occurred during migration`)
-      }
-    } catch (err) {
-      if (tty) process.stderr.write("\x1b[?25h")
-      UI.error(`Migration failed: ${errorMessage(err)}`)
-      process.exit(1)
-    } finally {
-      sqlite.close()
-    }
-  },
-})
-
-export const DbCommand = cmd({
-  command: "db",
-  describe: "database tools",
-  builder: (yargs: Argv) => {
-    return yargs.command(QueryCommand).command(PathCommand).command(MigrateCommand).demandCommand()
-  },
-  handler: () => {},
-})