Onchain

# Only publish SKILL.md and README.md for the skill
# Exclude everything else

# Source code
src/
dist/
tests/
scripts/

# Config files
*.json
*.json5
*.yaml
*.yml
*.toml
biome.json
tsconfig*.json
pnpm-lock.yaml

# Docs (except README and SKILL)
CLAUDE.md
CONTRIBUTING.md
LICENSE

# GitHub
.github/

name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install --frozen-lockfile
      - run: pnpm run lint

  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install --frozen-lockfile
      - run: pnpm run test

  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
      - run: pnpm install --frozen-lockfile
      - run: pnpm run build:dist

name: Publish to npm

on:
  push:
    tags:
      - 'v*'

jobs:
  publish:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      id-token: write
    steps:
      - uses: actions/checkout@v4

      - uses: pnpm/action-setup@v4

      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
          registry-url: https://registry.npmjs.org

      - run: pnpm install --frozen-lockfile
      - run: pnpm run lint
      - run: pnpm run test
      - run: pnpm run build:dist

      - run: npm publish --provenance --access public
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

# Dependencies
node_modules/

# Build output
dist/
*.tsbuildinfo

# Compiled binary
onchain

# Environment and secrets
.env
.env.*
!.env.example

# Config files with credentials
.onchainrc.json5

# IDE
.idea/
.vscode/
*.swp
*.swo
*~

# OS
.DS_Store
Thumbs.db

# Test coverage
coverage/

# Logs
*.log
npm-debug.log*
pnpm-debug.log*

# Lock files (using pnpm)
package-lock.json
yarn.lock

{
  "$schema": "https://biomejs.dev/schemas/latest/schema.json",
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineWidth": 120
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "complexity": {
        "noForEach": "error"
      },
      "correctness": {
        "useImportExtensions": {
          "level": "error",
          "options": {
            "forceJsExtensions": true
          }
        }
      },
      "performance": {
        "useTopLevelRegex": "error"
      },
      "style": {
        "noNegationElse": "error",
        "noNonNullAssertion": "error",
        "useBlockStatements": "error",
        "useConst": "error",
        "useTemplate": "error"
      },
      "suspicious": {
        "noExplicitAny": "error"
      },
      "nursery": {
        "useRegexpExec": "error"
      }
    }
  },
  "javascript": {
    "formatter": {
      "quoteStyle": "single",
      "semicolons": "always"
    }
  },
  "files": {
    "includes": ["src/**/*.{ts,tsx}", "tests/**/*.{ts,tsx}"],
    "ignoreUnknown": true
  }
}

MIT License

Copyright (c) 2025 cyberdrk305

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

{
  "name": "@skillhq/onchain",
  "version": "0.8.0",
  "description": "CLI tool for crypto portfolio tracking, market data, and CEX history",
  "type": "module",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "bin": {
    "onchain": "dist/cli.js"
  },
  "files": [
    "dist",
    "README.md",
    "CHANGELOG.md",
    "LICENSE",
    "SKILL.md"
  ],
  "repository": {
    "type": "git",
    "url": "git+https://github.com/skillhq/onchain.git"
  },
  "homepage": "https://github.com/skillhq/onchain#readme",
  "bugs": {
    "url": "https://github.com/skillhq/onchain/issues"
  },
  "author": "skillhq",
  "license": "MIT",
  "keywords": [
    "crypto",
    "portfolio",
    "cli",
    "defi",
    "ethereum",
    "solana",
    "coinbase",
    "binance",
    "polymarket",
    "wallet"
  ],
  "publishConfig": {
    "access": "public"
  },
  "scripts": {
    "build": "pnpm run build:dist && pnpm run build:binary",
    "build:dist": "tsc",
    "build:binary": "ONCHAIN_VERSION=$(node -p \"require('./package.json').version\") ONCHAIN_GIT_SHA=$(git rev-parse --short=8 HEAD 2>/dev/null || true) bun build --compile --minify --env=ONCHAIN_* src/cli.ts --outfile onchain",
    "dev": "tsx src/cli.ts",
    "onchain": "pnpm run build:dist && node dist/cli.js",
    "test": "vitest run",
    "test:watch": "vitest",
    "lint": "pnpm run lint:biome && pnpm run lint:oxlint",
    "lint:biome": "biome check .",
    "lint:oxlint": "oxlint --type-aware --tsconfig tsconfig.oxlint.json --import-plugin --node-plugin --vitest-plugin --deny-warnings src tests",
    "lint:fix": "pnpm run lint:biome:fix && pnpm run lint:oxlint:fix",
    "lint:biome:fix": "biome check --write .",
    "lint:oxlint:fix": "oxlint --type-aware --tsconfig tsconfig.oxlint.json --import-plugin --node-plugin --vitest-plugin --deny-warnings --fix src tests",
    "format": "biome format --write .",
    "binary": "pnpm run build:binary"
  },
  "dependencies": {
    "@solana/web3.js": "^1.98.4",
    "@walletconnect/keyvaluestorage": "^1.1.1",
    "@walletconnect/sign-client": "^2.23.4",
    "commander": "^14.0.0",
    "json5": "^2.2.3",
    "kleur": "^4.1.5",
    "qrcode-terminal": "^0.12.0",
    "viem": "^2.45.0"
  },
  "devDependencies": {
    "@biomejs/biome": "^2.3.10",
    "@types/node": "^25.0.0",
    "@types/qrcode-terminal": "^0.12.2",
    "@vitest/coverage-v8": "^4.0.0",
    "oxlint": "^1.36.0",
    "oxlint-tsgolint": "^0.11.0",
    "tsx": "^4.21.0",
    "typescript": "^5.9.0",
    "vitest": "^4.0.0"
  },
  "engines": {
    "node": ">=22"
  },
  "packageManager": "pnpm@10.25.0+sha512.5e82639027af37cf832061bcc6d639c219634488e0f2baebe785028a793de7b525ffcd3f7ff574f5e9860654e098fe852ba8ac5dd5cefe1767d23a020a92f501"
}

#!/usr/bin/env bash
set -euo pipefail

# Publish onchain skill to ClawdHub
# Usage:
#   ./scripts/publish-skill.sh              # Use version from package.json
#   ./scripts/publish-skill.sh 0.2.0        # Specify version
#   ./scripts/publish-skill.sh patch        # Bump patch (0.1.0 -> 0.1.1)
#   ./scripts/publish-skill.sh minor        # Bump minor (0.1.0 -> 0.2.0)
#   ./scripts/publish-skill.sh major        # Bump major (0.1.0 -> 1.0.0)

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
cd "$PROJECT_DIR"

# Read current version from package.json
CURRENT_VERSION=$(node -p "require('./package.json').version")

# Determine target version
if [[ $# -eq 0 ]]; then
    VERSION="$CURRENT_VERSION"
elif [[ "$1" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
    VERSION="$1"
elif [[ "$1" == "patch" || "$1" == "minor" || "$1" == "major" ]]; then
    IFS='.' read -r major minor patch <<< "$CURRENT_VERSION"
    case "$1" in
        patch) VERSION="$major.$minor.$((patch + 1))" ;;
        minor) VERSION="$major.$((minor + 1)).0" ;;
        major) VERSION="$((major + 1)).0.0" ;;
    esac
else
    echo "Usage: $0 [version|patch|minor|major]"
    echo "  version: semver like 0.2.0"
    echo "  patch:   bump patch version"
    echo "  minor:   bump minor version"
    echo "  major:   bump major version"
    exit 1
fi

# Get changelog from git (commits since last tag, or last 5 commits)
LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
if [[ -n "$LAST_TAG" ]]; then
    CHANGELOG=$(git log "$LAST_TAG"..HEAD --oneline --no-decorate | head -10 | sed 's/^/- /')
else
    CHANGELOG=$(git log -5 --oneline --no-decorate | sed 's/^/- /')
fi

if [[ -z "$CHANGELOG" ]]; then
    CHANGELOG="Version $VERSION"
fi

echo "Publishing onchain skill v$VERSION"
echo "Changelog:"
echo "$CHANGELOG"
echo ""

# Update package.json version if different
if [[ "$VERSION" != "$CURRENT_VERSION" ]]; then
    echo "Updating package.json version: $CURRENT_VERSION -> $VERSION"
    npm pkg set version="$VERSION"
fi

# Publish to ClawdHub
# Note: --workdir is required to override clawdbot default workspace
TAGS="latest,crypto,blockchain,portfolio,defi,wallet,prices,bitcoin,ethereum,solana,polymarket,coinbase,binance,trading"

clawdhub --workdir "$PROJECT_DIR" publish . \
    --slug onchain \
    --name "Onchain CLI" \
    --version "$VERSION" \
    --tags "$TAGS" \
    --changelog "$CHANGELOG"

echo ""
echo "Published onchain@$VERSION to ClawdHub"

#!/usr/bin/env node
import { createProgram } from './cli/program.js';
import { createCliContext } from './cli/shared.js';

const ctx = createCliContext(process.argv);
const program = createProgram(ctx);

program.parseAsync(process.argv).catch((error) => {
  console.error(`${ctx.p('err')}${error instanceof Error ? error.message : String(error)}`);
  process.exit(1);
});

import { readFileSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { Command } from 'commander';
import { registerBalanceCommand } from '../commands/balance.js';
import { registerBinanceCommands } from '../commands/binance.js';
import { registerCoinbaseCommands } from '../commands/coinbase.js';
import { registerConfigCommand } from '../commands/config.js';
import { registerGasCommand } from '../commands/gas.js';
import { registerHistoryCommand } from '../commands/history.js';
import { registerMarketsCommand } from '../commands/markets.js';
import { registerNansenCommands } from '../commands/nansen.js';
import { registerPolymarketCommands } from '../commands/polymarket.js';
import { registerPortfolioCommand } from '../commands/portfolio.js';
import { registerPriceCommand } from '../commands/price.js';
import { registerSearchCommand } from '../commands/search.js';
import { registerSetupCommand } from '../commands/setup.js';
import { registerTestCommand } from '../commands/test.js';
import { registerTxCommand } from '../commands/tx.js';
import { registerWalletCommand } from '../commands/wallet.js';
import type { CliContext } from './shared.js';

// Read version from package.json (works in both dev and built modes)
function getPackageVersion(): string {
  // Check env var first (set during binary build)
  if (process.env.ONCHAIN_VERSION) {
    return process.env.ONCHAIN_VERSION;
  }
  // Fall back to reading package.json
  try {
    const __dirname = dirname(fileURLToPath(import.meta.url));
    // In dev: src/cli/program.ts -> ../../package.json
    // In dist: dist/cli/program.js -> ../../package.json
    const pkgPath = join(__dirname, '..', '..', 'package.json');
    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { version: string };
    return pkg.version;
  } catch {
    return '0.0.0';
  }
}

const version = getPackageVersion();
const gitSha = process.env.ONCHAIN_GIT_SHA ?? '';

export function createProgram(ctx: CliContext): Command {
  const program = new Command();

  program
    .name('onchain')
    .description('CLI for crypto portfolio tracking, market data, and CEX history')
    .version(gitSha ? `${version} (${gitSha})` : version, '-V, --version')
    .option('--plain', 'Disable colors and emoji')
    .option('--no-emoji', 'Disable emoji')
    .option('--no-color', 'Disable colors')
    .option('--json', 'Output as JSON')
    .option('--timeout <ms>', 'Request timeout in milliseconds')
    .hook('preAction', (thisCommand) => {
      ctx.applyOutputFromCommand(thisCommand);
    });

  // Register all commands
  registerBalanceCommand(program, ctx);
  registerHistoryCommand(program, ctx);
  registerPortfolioCommand(program, ctx);
  registerPriceCommand(program, ctx);
  registerMarketsCommand(program, ctx);
  registerGasCommand(program, ctx);
  registerSearchCommand(program, ctx);
  registerTxCommand(program, ctx);
  registerCoinbaseCommands(program, ctx);
  registerBinanceCommands(program, ctx);
  registerPolymarketCommands(program, ctx);
  registerNansenCommands(program, ctx);
  registerWalletCommand(program, ctx);
  registerSetupCommand(program, ctx);
  registerConfigCommand(program, ctx);
  registerTestCommand(program, ctx);

  return program;
}

import * as readline from 'node:readline';
import type { OnchainConfig } from '../lib/config.js';

function createPrompt(): {
  question: (prompt: string) => Promise<string>;
  close: () => void;
} {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  return {
    question: (prompt: string) =>
      new Promise((resolve) => {
        rl.question(prompt, resolve);
      }),
    close: () => rl.close(),
  };
}

export async function runSetupWizard(
  existingConfig: OnchainConfig,
  colors: {
    section: (s: string) => string;
    accent: (s: string) => string;
    muted: (s: string) => string;
  },
): Promise<Partial<OnchainConfig>> {
  const prompt = createPrompt();
  const config: Partial<OnchainConfig> = {};

  console.log();
  console.log(colors.section('Onchain CLI Setup'));
  console.log(colors.muted('Press Enter to skip any field and keep the existing value.'));
  console.log();

  try {
    console.log(colors.accent('API Keys'));
    console.log(colors.muted('These can also be set via environment variables.'));
    console.log();

    // DeBank API Key
    const debankKey = await prompt.question(`DeBank API Key${existingConfig.debankApiKey ? ' (configured)' : ''}: `);
    if (debankKey) {
      config.debankApiKey = debankKey;
    }

    // Helius API Key
    const heliusKey = await prompt.question(`Helius API Key${existingConfig.heliusApiKey ? ' (configured)' : ''}: `);
    if (heliusKey) {
      config.heliusApiKey = heliusKey;
    }

    // Zerion API Key
    console.log();
    console.log(colors.muted('Zerion (unified EVM + Solana portfolio & history, get key at https://zerion.io/api):'));
    const zerionKey = await prompt.question(`  Zerion API Key${existingConfig.zerionApiKey ? ' (configured)' : ''}: `);
    if (zerionKey) {
      config.zerionApiKey = zerionKey;
    }

    // Coinbase CDP API (JWT-based auth with ECDSA)
    console.log();
    console.log(colors.muted('Coinbase CDP API (create keys at https://portal.cdp.coinbase.com/):'));
    console.log(colors.muted('  IMPORTANT: Select ECDSA as signature algorithm (NOT Ed25519)'));
    console.log(colors.muted('  API Key ID format: organizations/{org_id}/apiKeys/{key_id}'));
    const coinbaseApiKeyId = await prompt.question(
      `  Coinbase API Key ID${existingConfig.coinbaseApiKeyId ? ' (configured)' : ''}: `,
    );
    if (coinbaseApiKeyId) {
      config.coinbaseApiKeyId = coinbaseApiKeyId;
    }

    console.log(colors.muted('  Secret: paste the EC private key PEM (multiline, end with empty line)'));
    console.log(colors.muted('  Or set COINBASE_API_KEY_SECRET env var with the PEM content'));
    const existingSecret = existingConfig.coinbaseApiKeySecret;
    const secretPrompt = `  Coinbase API Key Secret${existingSecret ? ' (configured, press Enter to keep)' : ''}: `;
    let coinbaseApiKeySecret = await prompt.question(secretPrompt);

    // Handle multiline PEM input
    if (coinbaseApiKeySecret.startsWith('-----BEGIN')) {
      const lines = [coinbaseApiKeySecret];
      while (true) {
        const line = await prompt.question('');
        if (!line) {
          break;
        }
        lines.push(line);
        if (line.includes('-----END')) {
          break;
        }
      }
      coinbaseApiKeySecret = lines.join('\n');
    }

    if (coinbaseApiKeySecret) {
      config.coinbaseApiKeySecret = coinbaseApiKeySecret;
    }

    // Binance
    console.log();
    console.log(colors.muted('Binance (read-only API keys):'));
    const binanceKey = await prompt.question(
      `  Binance API Key${existingConfig.binanceApiKey ? ' (configured)' : ''}: `,
    );
    if (binanceKey) {
      config.binanceApiKey = binanceKey;
    }

    const binanceSecret = await prompt.question(
      `  Binance API Secret${existingConfig.binanceApiSecret ? ' (configured)' : ''}: `,
    );
    if (binanceSecret) {
      config.binanceApiSecret = binanceSecret;
    }

    // CoinGecko (optional)
    console.log();
    const coingeckoKey = await prompt.question(
      `CoinGecko Pro API Key (optional)${existingConfig.coingeckoApiKey ? ' (configured)' : ''}: `,
    );
    if (coingeckoKey) {
      config.coingeckoApiKey = coingeckoKey;
    }

    // CoinMarketCap (optional fallback)
    const cmcKey = await prompt.question(
      `CoinMarketCap API Key (optional fallback)${existingConfig.coinmarketcapApiKey ? ' (configured)' : ''}: `,
    );
    if (cmcKey) {
      config.coinmarketcapApiKey = cmcKey;
    }

    // Block Explorer APIs
    console.log();
    console.log(colors.accent('Block Explorer APIs'));
    console.log(colors.muted('For transaction lookup (onchain tx <hash>)'));
    console.log();

    // Etherscan (works on multiple EVM chains)
    const etherscanKey = await prompt.question(
      `Etherscan API Key${existingConfig.etherscanApiKey ? ' (configured)' : ''}: `,
    );
    if (etherscanKey) {
      config.etherscanApiKey = etherscanKey;
    }

    // Solscan (Solana)
    const solscanKey = await prompt.question(`Solscan API Key${existingConfig.solscanApiKey ? ' (configured)' : ''}: `);
    if (solscanKey) {
      config.solscanApiKey = solscanKey;
    }

    // WalletConnect
    console.log();
    console.log(colors.accent('WalletConnect'));
    console.log(colors.muted('For wallet connectivity (send transactions via mobile wallets)'));
    console.log(colors.muted('Get a free Project ID at https://dashboard.walletconnect.com/'));
    console.log();

    const walletConnectProjectId = await prompt.question(
      `WalletConnect Project ID${existingConfig.walletConnectProjectId ? ' (configured)' : ''}: `,
    );
    if (walletConnectProjectId) {
      config.walletConnectProjectId = walletConnectProjectId;
    }

    // Polymarket Preferences
    console.log();
    console.log(colors.accent('Polymarket Preferences'));
    console.log(colors.muted('Configure tag filters for polymarket trending/search commands.'));
    console.log(colors.muted('Run `onchain polymarket tags --popular` to see available tags.'));
    console.log();

    const existingExcludes = existingConfig.polymarket?.excludeTags?.join(', ') || '';
    const excludePrompt = existingExcludes
      ? `Exclude tags (comma-separated, currently: ${existingExcludes}): `
      : 'Exclude tags (comma-separated, e.g., sports,nfl,nba): ';
    const excludeInput = await prompt.question(excludePrompt);

    if (excludeInput) {
      const excludeTags = excludeInput
        .split(',')
        .map((t) => t.trim().toLowerCase())
        .filter(Boolean);
      if (excludeTags.length > 0) {
        config.polymarket = { ...config.polymarket, excludeTags };
      }
    }

    const existingIncludes = existingConfig.polymarket?.includeTags?.join(', ') || '';
    const includePrompt = existingIncludes
      ? `Include only tags (comma-separated, currently: ${existingIncludes}): `
      : 'Include only tags (comma-separated, leave empty for all): ';
    const includeInput = await prompt.question(includePrompt);

    if (includeInput) {
      const includeTags = includeInput
        .split(',')
        .map((t) => t.trim().toLowerCase())
        .filter(Boolean);
      if (includeTags.length > 0) {
        config.polymarket = { ...config.polymarket, includeTags };
      }
    }

    console.log();
    return config;
  } finally {
    prompt.close();
  }
}

import type { Command } from 'commander';
import kleur from 'kleur';
import { loadConfig, type OnchainConfig } from '../lib/config.js';
import { type ResolvedCredentials, resolveCredentials } from '../lib/credentials.js';
import type { OnchainClientOptions } from '../lib/onchain-client-types.js';
import {
  type LabelKind,
  labelPrefix,
  type OutputConfig,
  resolveOutputConfigFromArgv,
  resolveOutputConfigFromCommander,
  type StatusKind,
  statusPrefix,
} from '../lib/output.js';

export type CliContext = {
  isTty: boolean;
  getOutput: () => OutputConfig;
  colors: {
    banner: (t: string) => string;
    subtitle: (t: string) => string;
    section: (t: string) => string;
    bullet: (t: string) => string;
    command: (t: string) => string;
    option: (t: string) => string;
    argument: (t: string) => string;
    description: (t: string) => string;
    muted: (t: string) => string;
    accent: (t: string) => string;
    positive: (t: string) => string;
    negative: (t: string) => string;
  };
  p: (kind: StatusKind) => string;
  l: (kind: LabelKind) => string;
  config: OnchainConfig;
  applyOutputFromCommand: (command: Command) => void;
  resolveTimeoutFromOptions: (options: { timeout?: string | number }) => number | undefined;
  resolveCredentials: () => ResolvedCredentials;
  getClientOptions: () => OnchainClientOptions;
  outputJson: (data: unknown) => void;
};

function resolveTimeoutMs(...values: Array<string | number | undefined | null>): number | undefined {
  for (const value of values) {
    if (value === undefined || value === null || value === '') {
      continue;
    }
    const parsed = typeof value === 'number' ? value : Number(value);
    if (Number.isFinite(parsed) && parsed > 0) {
      return parsed;
    }
  }
  return undefined;
}

export function createCliContext(normalizedArgs: string[], env: NodeJS.ProcessEnv = process.env): CliContext {
  const isTty = process.stdout.isTTY ?? false;
  let output: OutputConfig = resolveOutputConfigFromArgv(normalizedArgs, env, isTty);
  kleur.enabled = output.color;

  const wrap =
    (styler: (text: string) => string): ((text: string) => string) =>
    (text: string): string =>
      isTty ? styler(text) : text;

  const colors = {
    banner: wrap((t) => kleur.bold().magenta(t)),
    subtitle: wrap((t) => kleur.dim(t)),
    section: wrap((t) => kleur.bold().white(t)),
    bullet: wrap((t) => kleur.magenta(t)),
    command: wrap((t) => kleur.bold().cyan(t)),
    option: wrap((t) => kleur.cyan(t)),
    argument: wrap((t) => kleur.magenta(t)),
    description: wrap((t) => kleur.white(t)),
    muted: wrap((t) => kleur.gray(t)),
    accent: wrap((t) => kleur.cyan(t)),
    positive: wrap((t) => kleur.green(t)),
    negative: wrap((t) => kleur.red(t)),
  };

  const p = (kind: StatusKind): string => {
    const prefix = statusPrefix(kind, output);
    if (output.plain || !output.color) {
      return prefix;
    }
    if (kind === 'ok') {
      return kleur.green(prefix);
    }
    if (kind === 'warn') {
      return kleur.yellow(prefix);
    }
    if (kind === 'err') {
      return kleur.red(prefix);
    }
    if (kind === 'info') {
      return kleur.cyan(prefix);
    }
    return kleur.gray(prefix);
  };

  const l = (kind: LabelKind): string => {
    const prefix = labelPrefix(kind, output);
    if (output.plain || !output.color) {
      return prefix;
    }
    const colorMap: Record<LabelKind, (s: string) => string> = {
      url: kleur.cyan,
      date: kleur.magenta,
      wallet: kleur.yellow,
      chain: kleur.blue,
      token: kleur.cyan,
      price: kleur.green,
      value: kleur.yellow,
      change: kleur.magenta,
      balance: kleur.blue,
      position: kleur.cyan,
      exchange: kleur.yellow,
    };
    return colorMap[kind](prefix);
  };

  const config = loadConfig((message) => {
    console.error(colors.muted(`${p('warn')}${message}`));
  });

  function applyOutputFromCommand(command: Command): void {
    const opts = command.optsWithGlobals() as { plain?: boolean; emoji?: boolean; color?: boolean; json?: boolean };
    output = resolveOutputConfigFromCommander(opts, env, isTty);
    kleur.enabled = output.color;
  }

  function resolveTimeoutFromOptions(options: { timeout?: string | number }): number | undefined {
    return resolveTimeoutMs(options.timeout, config.timeoutMs, env.ONCHAIN_TIMEOUT_MS);
  }

  function getResolvedCredentials(): ResolvedCredentials {
    return resolveCredentials(config, env);
  }

  function getClientOptions(): OnchainClientOptions {
    const creds = getResolvedCredentials();
    return {
      debankApiKey: creds.debankApiKey,
      heliusApiKey: creds.heliusApiKey,
      coinbaseApiKeyId: creds.coinbaseApiKeyId,
      coinbaseApiKeySecret: creds.coinbaseApiKeySecret,
      binanceApiKey: creds.binanceApiKey,
      binanceApiSecret: creds.binanceApiSecret,
      coingeckoApiKey: creds.coingeckoApiKey,
      coinmarketcapApiKey: creds.coinmarketcapApiKey,
      etherscanApiKey: creds.etherscanApiKey,
      solscanApiKey: creds.solscanApiKey,
      walletConnectProjectId: creds.walletConnectProjectId,
      zerionApiKey: creds.zerionApiKey,
      timeoutMs: config.timeoutMs,
    };
  }

  function outputJson(data: unknown): void {
    console.log(JSON.stringify(data, null, 2));
  }

  return {
    isTty,
    getOutput: () => output,
    colors,
    p,
    l,
    config,
    applyOutputFromCommand,
    resolveTimeoutFromOptions,
    resolveCredentials: getResolvedCredentials,
    getClientOptions,
    outputJson,
  };
}

import type { Command } from 'commander';
import type { CliContext } from '../cli/shared.js';
import { isAgentBrowserAvailable, scrapeDebankProfile, scrapeSolscanProfile } from '../lib/browser-scraper.js';
import { validateCredentials } from '../lib/credentials.js';
import { OnchainClient } from '../lib/onchain-client.js';
import type { EvmChain, SupportedChain, TokenBalance } from '../lib/onchain-client-types.js';
import { isEvmAddress, isSolanaAddress } from '../lib/utils/address.js';
import { formatChainName, formatTokenAmount, formatUsd } from '../lib/utils/formatters.js';

export function registerBalanceCommand(program: Command, ctx: CliContext): void {
  program
    .command('balance')
    .description('Get wallet token balances')
    .argument('<address>', 'Wallet address (EVM 0x... or Solana)')
    .option('--chain <chain>', 'Filter by specific chain (for EVM wallets)')
    .option('--min-value <usd>', 'Minimum USD value to show', '0')
    .option('-n, --limit <number>', 'Maximum tokens to show', '50')
    .option('--browser', 'Use browser scraping (requires agent-browser CLI)')
    .option('--json', 'Output as JSON')
    .action(
      async (
        address: string,
        cmdOpts: { chain?: string; minValue?: string; limit?: string; browser?: boolean; json?: boolean },
      ) => {
        const opts = program.opts();
        const timeoutMs = ctx.resolveTimeoutFromOptions(opts);
        const clientOpts = ctx.getClientOptions();
        clientOpts.timeoutMs = timeoutMs;

        // Detect chain type from address format
        let chainType: 'evm' | 'solana';
        if (isEvmAddress(address)) {
          chainType = 'evm';
        } else if (isSolanaAddress(address)) {
          chainType = 'solana';
        } else {
          console.error(`${ctx.p('err')}Invalid address format. Expected EVM (0x...) or Solana address.`);
          process.exit(1);
        }

        // Check credentials
        const creds = ctx.resolveCredentials();
        const validation = validateCredentials(creds);

        // Initialize client to check for Nansen availability
        const client = new OnchainClient(clientOpts);
        const useNansen = client.isNansenAvailable();
        const hasApiKey = chainType === 'evm' ? validation.hasDebank : validation.hasHelius;
        const useBrowser = cmdOpts.browser || (!validation.hasZerion && !useNansen && !hasApiKey);

        const output = ctx.getOutput();
        const colors = ctx.colors;

        let balances: TokenBalance[] = [];
        let totalValueUsd = 0;
        let source: 'zerion' | 'nansen' | 'api' | 'browser' = 'api';

        // Try Zerion first (highest priority when configured)
        if (validation.hasZerion && !cmdOpts.browser) {
          source = 'zerion';
          const chains = cmdOpts.chain ? [cmdOpts.chain as EvmChain] : undefined;
          const result = await client.getZerionBalances(address, chains);

          if (result.success) {
            balances = result.balances;
            totalValueUsd = result.totalValueUsd;
          } else {
            console.error(colors.muted(`Zerion failed: ${result.error}, falling back...`));
            source = 'api';
          }
        }

        // Try Nansen CLI if Zerion not available or failed
        if (source === 'api' && useNansen && !cmdOpts.browser) {
          source = 'nansen';
          const chain: SupportedChain = chainType === 'evm' ? ((cmdOpts.chain as EvmChain) ?? 'eth') : 'solana';

          const result = await client.getNansenBalances(address, chain);

          if (result.success) {
            balances = result.balances;
            totalValueUsd = result.totalValueUsd;
          } else {
            console.error(colors.muted(`Nansen failed: ${result.error}, falling back to API...`));
            source = 'api';
          }
        }

        // Use DeBank/Helius API fallback
        if (source === 'api' && !useBrowser) {
          if (chainType === 'evm') {
            const chains = cmdOpts.chain ? [cmdOpts.chain as EvmChain] : undefined;
            const result = await client.getEvmBalances(address, chains);

            if (!result.success) {
              console.error(`${ctx.p('err')}${result.error}`);
              process.exit(1);
            }

            balances = result.balances;
            totalValueUsd = result.totalValueUsd;
          } else if (chainType === 'solana') {
            const result = await client.getSolanaBalances(address);

            if (!result.success) {
              console.error(`${ctx.p('err')}${result.error}`);
              process.exit(1);
            }

            balances = result.balances;
            totalValueUsd = result.totalValueUsd;
          }
        }

        // Use browser scraping as last resort
        if (useBrowser || (source === 'api' && balances.length === 0 && !hasApiKey)) {
          source = 'browser';

          if (!isAgentBrowserAvailable()) {
            const apiKeyName = chainType === 'evm' ? 'DEBANK_API_KEY' : 'HELIUS_API_KEY';
            console.error(
              `${ctx.p('err')}No API key configured and agent-browser CLI not available.\n` +
                `Set ${apiKeyName} or install agent-browser for browser scraping.`,
            );
            process.exit(1);
          }

          console.error(colors.muted('Using browser scraping (no API key configured)...'));

          const scrapeResult =
            chainType === 'evm'
              ? await scrapeDebankProfile(address, timeoutMs ?? 60000)
              : await scrapeSolscanProfile(address, timeoutMs ?? 60000);

          if (!scrapeResult.success) {
            console.error(`${ctx.p('err')}${scrapeResult.error}`);
            process.exit(1);
          }

          // Convert scraped balances to TokenBalance format
          balances = scrapeResult.balances.map((b) => ({
            symbol: b.symbol,
            name: b.name,
            chain: (b.chain ?? chainType) as EvmChain | 'solana',
            balanceRaw: String(b.amount),
            balanceFormatted: b.amount,
            decimals: 0,
            priceUsd: b.valueUsd && b.amount > 0 ? b.valueUsd / b.amount : null,
            valueUsd: b.valueUsd,
          }));
          totalValueUsd = scrapeResult.totalValueUsd;
        }

        // Apply filters
        const minValue = Number.parseFloat(cmdOpts.minValue ?? '0');
        const limit = Number.parseInt(cmdOpts.limit ?? '50', 10);

        let filteredBalances = balances.filter((b) => (b.valueUsd ?? 0) >= minValue);
        filteredBalances = filteredBalances.slice(0, limit);

        if (cmdOpts.json || output.json) {
          ctx.outputJson({
            address,
            chainType,
            totalValueUsd,
            balances: filteredBalances,
            source,
          });
          return;
        }

        console.log();
        console.log(colors.section('Wallet Balance'));
        console.log(colors.muted(`${address}`));
        if (source === 'nansen') {
          console.log(colors.muted('(via Nansen CLI)'));
        } else if (source === 'zerion') {
          console.log(colors.muted('(via Zerion API)'));
        } else if (source === 'browser') {
          console.log(colors.muted('(via browser scraping)'));
        }
        console.log();

        if (filteredBalances.length === 0) {
          console.log(colors.muted('No tokens found with value above minimum threshold.'));
          console.log();
          return;
        }

        // Header
        console.log(
          `${'Token'.padEnd(12)} ${'Amount'.padStart(16)} ${'Price'.padStart(12)} ${'Value'.padStart(14)} ${'Chain'.padEnd(10)}`,
        );
        console.log('-'.repeat(70));

        for (const balance of filteredBalances) {
          const symbol = balance.symbol.slice(0, 10).padEnd(12);
          const amount = formatTokenAmount(balance.balanceFormatted).padStart(16);
          const price = balance.priceUsd !== null ? formatUsd(balance.priceUsd).padStart(12) : '-'.padStart(12);
          const value = balance.valueUsd !== null ? formatUsd(balance.valueUsd).padStart(14) : '-'.padStart(14);
          const chain = formatChainName(balance.chain).slice(0, 10).padEnd(10);

          console.log(`${symbol} ${amount} ${price} ${value} ${colors.muted(chain)}`);
        }

        console.log('-'.repeat(70));
        console.log(
          `${'Total'.padEnd(12)} ${' '.padStart(16)} ${' '.padStart(12)} ${formatUsd(totalValueUsd).padStart(14)}`,
        );
        console.log();

        if (balances.length > filteredBalances.length) {
          console.log(
            colors.muted(`Showing ${filteredBalances.length} of ${balances.length} tokens (use --limit to show more)`),
          );
          console.log();
        }
      },
    );
}

import type { Command } from 'commander';
import type { CliContext } from '../cli/shared.js';
import { getMissingCredentialsMessage, validateCredentials } from '../lib/credentials.js';
import { OnchainClient } from '../lib/onchain-client.js';
import { formatRelativeTime, formatTokenAmount, formatUsd } from '../lib/utils/formatters.js';

export function registerBinanceCommands(program: Command, ctx: CliContext): void {
  const binance = program.command('binance').description('Binance exchange commands');

  binance
    .command('balance')
    .description('Get Binance account balances')
    .option('--min-value <usd>', 'Minimum USD value to show', '0')
    .option('--json', 'Output as JSON')
    .action(async (cmdOpts: { minValue?: string; json?: boolean }) => {
      const opts = program.opts();
      const timeoutMs = ctx.resolveTimeoutFromOptions(opts);
      const clientOpts = ctx.getClientOptions();
      clientOpts.timeoutMs = timeoutMs;

      // Validate credentials
      const creds = ctx.resolveCredentials();
      const validation = validateCredentials(creds);

      if (!validation.hasBinance) {
        console.error(`${ctx.p('err')}${getMissingCredentialsMessage('Binance', ['binance'])}`);
        process.exit(1);
      }

      const client = new OnchainClient(clientOpts);
      const result = await client.getBinanceBalances();

      if (!result.success) {
        console.error(`${ctx.p('err')}${result.error}`);
        process.exit(1);
      }

      const output = ctx.getOutput();
      const colors = ctx.colors;

      // Apply filters
      const minValue = Number.parseFloat(cmdOpts.minValue ?? '0');
      const filteredBalances = result.balances.filter((b) => (b.valueUsd ?? 0) >= minValue);

      if (cmdOpts.json || output.json) {
        ctx.outputJson({
          exchange: 'binance',
          totalValueUsd: result.totalValueUsd,
          balances: filteredBalances,
        });
        return;
      }

      console.log();
      console.log(colors.section('Binance Balance'));
      console.log();

      if (filteredBalances.length === 0) {
        console.log(colors.muted('No assets found with value above minimum threshold.'));
        console.log();
        return;
      }

      console.log(`${'Asset'.padEnd(10)} ${'Free'.padStart(14)} ${'Locked'.padStart(14)} ${'Value'.padStart(14)}`);
      console.log('-'.repeat(56));

      for (const balance of filteredBalances) {
        const asset = balance.asset.padEnd(10);
        const free = formatTokenAmount(balance.free).padStart(14);
        const locked = formatTokenAmount(balance.locked).padStart(14);
        const value = balance.valueUsd !== undefined ? formatUsd(balance.valueUsd).padStart(14) : '-'.padStart(14);

        const lockedDisplay = balance.locked > 0 ? colors.muted(locked) : locked;
        console.log(`${asset} ${free} ${lockedDisplay} ${value}`);
      }

      console.log('-'.repeat(56));
      console.log(
        `${'Total'.padEnd(10)} ${' '.padStart(14)} ${' '.padStart(14)} ${formatUsd(result.totalValueUsd).padStart(14)}`,
      );
      console.log();
    });

  binance
    .command('history')
    .description('Get Binance trade history')
    .option('--symbol <symbol>', 'Trading pair (e.g., BTCUSDT)')
    .option('-n, --limit <number>', 'Number of trades to fetch', '50')
    .option('--cursor <cursor>', 'Pagination cursor (trade ID)')
    .option('--json', 'Output as JSON')
    .action(async (cmdOpts: { symbol?: string; limit?: string; cursor?: string; json?: boolean }) => {
      const opts = program.opts();
      const timeoutMs = ctx.resolveTimeoutFromOptions(opts);
      const clientOpts = ctx.getClientOptions();
      clientOpts.timeoutMs = timeoutMs;

      // Validate credentials
      const creds = ctx.resolveCredentials();
      const validation = validateCredentials(creds);

      if (!validation.hasBinance) {
        console.error(`${ctx.p('err')}${getMissingCredentialsMessage('Binance', ['binance'])}`);
        process.exit(1);
      }

      const client = new OnchainClient(clientOpts);
      const limit = Number.parseInt(cmdOpts.limit ?? '50', 10);

      const result = await client.getBinanceHistory({
        symbol: cmdOpts.symbol,
        limit,
        cursor: cmdOpts.cursor,
      });

      if (!result.success) {
        console.error(`${ctx.p('err')}${result.error}`);
        process.exit(1);
      }

      const output = ctx.getOutput();
      const colors = ctx.colors;

      if (cmdOpts.json || output.json) {
        ctx.outputJson({
          exchange: 'binance',
          trades: result.trades,
          nextCursor: result.nextCursor,
        });
        return;
      }

      console.log();
      console.log(colors.section('Binance Trade History'));
      console.log();

      if (result.trades.length === 0) {
        console.log(colors.muted('No trades found.'));
        console.log();
        return;
      }

      for (const trade of result.trades) {
        const sideColor = trade.side === 'buy' ? colors.positive : colors.negative;
        const sideLabel = sideColor(trade.side.toUpperCase().padEnd(4));

        console.log(`${sideLabel} ${trade.symbol}`);
        console.log(`  ${formatTokenAmount(trade.quantity)} @ ${formatUsd(trade.price)} = ${formatUsd(trade.total)}`);
        if (trade.fee && trade.feeAsset) {
          console.log(colors.muted(`  Fee: ${formatTokenAmount(trade.fee)} ${trade.feeAsset}`));
        }
        console.log(colors.muted(`  ${formatRelativeTime(trade.timestamp)}`));
        console.log();
      }

      if (result.nextCursor) {
        console.log(colors.muted(`Use --cursor "${result.nextCursor}" to see more trades`));
        console.log();
      }
    });
}

import type { Command } from 'commander';
import type { CliContext } from '../cli/shared.js';
import { getMissingCredentialsMessage, validateCredentials } from '../lib/credentials.js';
import { OnchainClient } from '../lib/onchain-client.js';
import { formatRelativeTime, formatTokenAmount, formatUsd } from '../lib/utils/formatters.js';

export function registerCoinbaseCommands(program: Command, ctx: CliContext): void {
  const coinbase = program.command('coinbase').description('Coinbase exchange commands');

  coinbase
    .command('balance')
    .description('Get Coinbase account balances')
    .option('--min-value <usd>', 'Minimum USD value to show', '0')
    .option('--json', 'Output as JSON')
    .action(async (cmdOpts: { minValue?: string; json?: boolean }) => {
      const opts = program.opts();
      const timeoutMs = ctx.resolveTimeoutFromOptions(opts);
      const clientOpts = ctx.getClientOptions();
      clientOpts.timeoutMs = timeoutMs;

      // Validate credentials
      const creds = ctx.resolveCredentials();
      const validation = validateCredentials(creds);

      if (!validation.hasCoinbase) {
        console.error(`${ctx.p('err')}${getMissingCredentialsMessage('Coinbase', ['coinbase'])}`);
        process.exit(1);
      }

      const client = new OnchainClient(clientOpts);
      const result = await client.getCoinbaseBalances();

      if (!result.success) {
        console.error(`${ctx.p('err')}${result.error}`);
        process.exit(1);
      }

      const output = ctx.getOutput();
      const colors = ctx.colors;

      // Apply filters
      const minValue = Number.parseFloat(cmdOpts.minValue ?? '0');
      const filteredBalances = result.balances.filter((b) => (b.valueUsd ?? 0) >= minValue);

      if (cmdOpts.json || output.json) {
        ctx.outputJson({
          exchange: 'coinbase',
          totalValueUsd: result.totalValueUsd,
          balances: filteredBalances,
        });
        return;
      }

      console.log();
      console.log(colors.section('Coinbase Balance'));
      console.log();

      if (filteredBalances.length === 0) {
        console.log(colors.muted('No assets found with value above minimum threshold.'));
        console.log();
        return;
      }

      console.log(`${'Asset'.padEnd(10)} ${'Amount'.padStart(16)} ${'Value'.padStart(14)}`);
      console.log('-'.repeat(44));

      for (const balance of filteredBalances) {
        const asset = balance.asset.padEnd(10);
        const amount = formatTokenAmount(balance.total).padStart(16);
        const value = balance.valueUsd !== undefined ? formatUsd(balance.valueUsd).padStart(14) : '-'.padStart(14);

        console.log(`${asset} ${amount} ${value}`);
      }

      console.log('-'.repeat(44));
      console.log(`${'Total'.padEnd(10)} ${' '.padStart(16)} ${formatUsd(result.totalValueUsd).padStart(14)}`);
      console.log();
    });

  coinbase
    .command('history')
    .description('Get Coinbase trade history')
    .option('-n, --limit <number>', 'Number of trades to fetch', '20')
    .option('--cursor <cursor>', 'Pagination cursor')
    .option('--json', 'Output as JSON')
    .action(async (cmdOpts: { limit?: string; cursor?: string; json?: boolean }) => {
      const opts = program.opts();
      const timeoutMs = ctx.resolveTimeoutFromOptions(opts);
      const clientOpts = ctx.getClientOptions();
      clientOpts.timeoutMs = timeoutMs;

      // Validate credentials
      const creds = ctx.resolveCredentials();
      const validation = validateCredentials(creds);

      if (!validation.hasCoinbase) {
        console.error(`${ctx.p('err')}${getMissingCredentialsMessage('Coinbase', ['coinbase'])}`);
        process.exit(1);
      }

      const client = new OnchainClient(clientOpts);
      const limit = Number.parseInt(cmdOpts.limit ?? '20', 10);

      const result = await client.getCoinbaseHistory({
        limit,
        cursor: cmdOpts.cursor,
      });

      if (!result.success) {
        console.error(`${ctx.p('err')}${result.error}`);
        process.exit(1);
      }

      const output = ctx.getOutput();
      const colors = ctx.colors;

      if (cmdOpts.json || output.json) {
        ctx.outputJson({
          exchange: 'coinbase',
          trades: result.trades,
          nextCursor: result.nextCursor,
        });
        return;
      }

      console.log();
      console.log(colors.section('Coinbase Trade History'));
      console.log();

      if (result.trades.length === 0) {
        console.log(colors.muted('No trades found.'));
        console.log();
        return;
      }

      for (const trade of result.trades) {
        const sideColor = trade.side === 'buy' ? colors.positive : colors.negative;
        const sideLabel = sideColor(trade.side.toUpperCase().padEnd(4));

        console.log(`${sideLabel} ${trade.symbol}`);
        console.log(`  ${formatTokenAmount(trade.quantity)} @ ${formatUsd(trade.price)} = ${formatUsd(trade.total)}`);
        console.log(colors.muted(`  ${formatRelativeTime(trade.timestamp)}`));
        console.log();
      }

      if (result.nextCursor) {
        console.log(colors.muted(`Use --cursor "${result.nextCursor}" to see more trades`));
        console.log();
      }
    });
}

import type { Command } from 'commander';
import type { CliContext } from '../cli/shared.js';
import { getConfigPath, saveConfig } from '../lib/config.js';
import { validateCredentials } from '../lib/credentials.js';

export function registerConfigCommand(program: Command, ctx: CliContext): void {
  const configCmd = program.command('config').description('View and manage configuration');

  // Default action: show config
  configCmd
    .command('show', { isDefault: true })
    .description('Show current configuration')
    .option('--json', 'Output as JSON')
    .action(async (cmdOpts: { json?: boolean }) => {
      const config = ctx.config;
      const creds = ctx.resolveCredentials();
      const validation = validateCredentials(creds);
      const colors = ctx.colors;
      const output = ctx.getOutput();

      if (cmdOpts.json || output.json) {
        // Don't expose secrets in JSON output
        const safeConfig = {
          timeoutMs: config.timeoutMs,
          credentials: {
            debank: validation.hasDebank,
            helius: validation.hasHelius,
            coinbase: validation.hasCoinbase,
            binance: validation.hasBinance,
            coingecko: validation.hasCoinGecko,
            coinmarketcap: validation.hasCoinMarketCap,
          },
        };
        ctx.outputJson(safeConfig);
        return;
      }

      console.log();
      console.log(colors.section('Configuration'));
      console.log();

      // Config paths
      console.log(colors.accent('Config Files:'));
      console.log(`  Global: ${getConfigPath({ global: true })}`);
      console.log(`  Local:  ${getConfigPath({ global: false })}`);
      console.log();

      // API Credentials Status
      console.log(colors.accent('API Credentials:'));
      const credStatus = (name: string, configured: boolean, source?: string): string => {
        const status = configured ? colors.positive('\u2713 configured') : colors.muted('not configured');
        const srcLabel = source ? colors.muted(` (${source})`) : '';
        return `  ${name.padEnd(15)} ${status}${srcLabel}`;
      };

      console.log(
        credStatus(
          'DeBank',
          validation.hasDebank,
          creds.debankApiKey ? (config.debankApiKey ? 'config' : 'env') : undefined,
        ),
      );
      console.log(
        credStatus(
          'Helius',
          validation.hasHelius,
          creds.heliusApiKey ? (config.heliusApiKey ? 'config' : 'env') : undefined,
        ),
      );
      console.log(
        credStatus(
          'Coinbase',
          validation.hasCoinbase,
          creds.coinbaseApiKeyId ? (config.coinbaseApiKeyId ? 'config' : 'env') : undefined,
        ),
      );
      console.log(
        credStatus(
          'Binance',
          validation.hasBinance,
          creds.binanceApiKey ? (config.binanceApiKey ? 'config' : 'env') : undefined,
        ),
      );
      console.log(
        credStatus(
          'CoinGecko',
          validation.hasCoinGecko,
          creds.coingeckoApiKey ? (config.coingeckoApiKey ? 'config' : 'env') : undefined,
        ),
      );
      console.log(
        credStatus(
          'CoinMarketCap',
          validation.hasCoinMarketCap,
          creds.coinmarketcapApiKey ? (config.coinmarketcapApiKey ? 'config' : 'env') : undefined,
        ),
      );
      console.log();

      // Settings
      console.log(colors.accent('Settings:'));
      console.log(`  Timeout: ${config.timeoutMs ?? 30000}ms`);
      console.log();
    });

  configCmd
    .command('set')
    .description('Set a configuration value')
    .argument('<key>', 'Configuration key (e.g., timeoutMs)')
    .argument('<value>', 'Value to set')
    .option('--global', 'Save to global config')
    .action(async (key: string, value: string, cmdOpts: { global?: boolean }) => {
      const colors = ctx.colors;

      const allowedKeys = ['timeoutMs'];
      if (!allowedKeys.includes(key)) {
        console.error(`${ctx.p('err')}Invalid key "${key}". Allowed keys: ${allowedKeys.join(', ')}`);
        console.error(colors.muted('Use `onchain setup` to configure API keys.'));
        process.exit(1);
      }

      const updates: Record<string, unknown> = {};

      if (key === 'timeoutMs') {
        const parsed = Number.parseInt(value, 10);
        if (!Number.isFinite(parsed) || parsed <= 0) {
          console.error(`${ctx.p('err')}Invalid timeout value. Expected positive integer.`);
          process.exit(1);
        }
        updates.timeoutMs = parsed;
      } else {
        updates[key] = value;
      }

      saveConfig(updates, { global: cmdOpts.global });

      const configPath = getConfigPath({ global: cmdOpts.global });
      console.log(`${ctx.p('ok')}Set ${key}=${value} in ${configPath}`);
    });
}