cli.ts

import { Command } from "commander"
import { OpenSeaAPIError, OpenSeaClient } from "./client.js"
import {
  accountsCommand,
  collectionsCommand,
  eventsCommand,
  healthCommand,
  listingsCommand,
  nftsCommand,
  offersCommand,
  searchCommand,
  swapsCommand,
  tokensCommand,
} from "./commands/index.js"
import type { OutputFilterOptions, OutputFormat } from "./output.js"
import { parseIntOption } from "./parse.js"

const EXIT_API_ERROR = 1
const EXIT_AUTH_ERROR = 2
const EXIT_RATE_LIMITED = 3

const BANNER = `
   ____                   _____
  / __ \\                 / ____|
 | |  | |_ __   ___ _ _| (___   ___  __ _
 | |  | | '_ \\ / _ \\ '_ \\___ \\ / _ \\/ _\` |
 | |__| | |_) |  __/ | | |___) |  __/ (_| |
  \\____/| .__/ \\___|_| |_|____/ \\___|\\__,_|
        | |
        |_|
`

const program = new Command()

program
  .name("opensea")
  .description("OpenSea CLI - Query the OpenSea API from the command line")
  .version(process.env.npm_package_version ?? "0.0.0")
  .addHelpText("before", BANNER)
  .option("--api-key <key>", "OpenSea API key (or set OPENSEA_API_KEY env var)")
  .option("--chain <chain>", "Default chain", "ethereum")
  .option("--format <format>", "Output format (json, table, or toon)", "json")
  .option("--base-url <url>", "API base URL")
  .option("--timeout <ms>", "Request timeout in milliseconds", "30000")
  .option("--retries <n>", "Max retries on 429/5xx errors", "3")
  .option("--verbose", "Log request and response info to stderr")
  .option(
    "--fields <fields>",
    "Comma-separated list of fields to include in output",
  )
  .option("--max-items <n>", "Truncate array output to first N items")

function getClient(): OpenSeaClient {
  const opts = program.opts<{
    apiKey?: string
    chain: string
    baseUrl?: string
    timeout: string
    retries: string
    verbose?: boolean
  }>()

  const apiKey = opts.apiKey ?? process.env.OPENSEA_API_KEY
  if (!apiKey) {
    console.error(
      "Error: API key required. Use --api-key or set OPENSEA_API_KEY environment variable.",
    )
    process.exit(EXIT_AUTH_ERROR)
  }

  return new OpenSeaClient({
    apiKey,
    chain: opts.chain,
    baseUrl: opts.baseUrl,
    timeout: parseIntOption(opts.timeout, "--timeout"),
    retries: parseIntOption(opts.retries, "--retries"),
    verbose: opts.verbose,
  })
}

function getFormat(): OutputFormat {
  const opts = program.opts<{ format: string }>()
  if (opts.format === "table") return "table"
  if (opts.format === "toon") return "toon"
  return "json"
}

function getFilters(): OutputFilterOptions {
  const opts = program.opts<{
    fields?: string
    maxItems?: string
  }>()
  return {
    fields: opts.fields
      ?.split(",")
      .map(f => f.trim())
      .filter(Boolean),
    maxItems: opts.maxItems
      ? parseIntOption(opts.maxItems, "--max-items")
      : undefined,
  }
}

program.addCommand(collectionsCommand(getClient, getFormat, getFilters))
program.addCommand(nftsCommand(getClient, getFormat, getFilters))
program.addCommand(listingsCommand(getClient, getFormat, getFilters))
program.addCommand(offersCommand(getClient, getFormat, getFilters))
program.addCommand(eventsCommand(getClient, getFormat, getFilters))
program.addCommand(accountsCommand(getClient, getFormat, getFilters))
program.addCommand(tokensCommand(getClient, getFormat, getFilters))
program.addCommand(searchCommand(getClient, getFormat, getFilters))
program.addCommand(swapsCommand(getClient, getFormat, getFilters))
program.addCommand(healthCommand(getClient))

async function main() {
  try {
    await program.parseAsync(process.argv)
  } catch (error) {
    if (error instanceof OpenSeaAPIError) {
      const isRateLimited = error.statusCode === 429
      console.error(
        JSON.stringify(
          {
            error: isRateLimited ? "Rate Limited" : "API Error",
            status: error.statusCode,
            path: error.path,
            message: error.responseBody,
          },
          null,
          2,
        ),
      )
      process.exit(isRateLimited ? EXIT_RATE_LIMITED : EXIT_API_ERROR)
    }
    const label =
      error instanceof TypeError ? "Network Error" : (error as Error).name
    console.error(
      JSON.stringify(
        {
          error: label,
          message: (error as Error).message,
        },
        null,
        2,
      ),
    )
    process.exit(EXIT_API_ERROR)
  }
}

main()