Aelfscan Skill

# Base URL of aelfscan API
AELFSCAN_API_BASE_URL=https://aelfscan.io

# Default chain id for requests when chainId is omitted.
# Use empty string for multi-chain scope.
AELFSCAN_DEFAULT_CHAIN_ID=

# HTTP timeout in milliseconds
AELFSCAN_TIMEOUT_MS=10000

# Retry count for transient request failures
AELFSCAN_RETRY=1

# Retry backoff base milliseconds and max milliseconds (exponential + jitter)
AELFSCAN_RETRY_BASE_MS=200
AELFSCAN_RETRY_MAX_MS=3000

# HTTP client concurrency limit
AELFSCAN_MAX_CONCURRENT_REQUESTS=5

# Default in-memory cache TTL for statistics GET requests (milliseconds)
AELFSCAN_CACHE_TTL_MS=60000
# Maximum in-memory cache entries before FIFO eviction
AELFSCAN_CACHE_MAX_ENTRIES=500

# Pagination maxResultCount upper bound
AELFSCAN_MAX_RESULT_COUNT=200

# MCP output controls
AELFSCAN_MCP_MAX_ITEMS=50
AELFSCAN_MCP_MAX_CHARS=60000
AELFSCAN_MCP_INCLUDE_RAW=false

name: Coverage Badge

on:
  push:
    branches:
      - main
      - master
      - 'codex/**'
  workflow_dispatch:

permissions:
  contents: write

jobs:
  coverage-badge:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - run: bun install --frozen-lockfile
      - run: bun run test:coverage:ci
      - run: bun run coverage:badge
      - run: touch coverage/.nojekyll

      - name: Deploy coverage badge to gh-pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./coverage
          publish_branch: gh-pages

name: Publish to npm

on:
  push:
    tags:
      - 'v*'
  workflow_dispatch:

permissions:
  id-token: write
  contents: read

jobs:
  verify:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Type check
        run: bunx tsc --noEmit

      - name: Coverage gate
        run: bun run test:coverage:ci

      - name: Verify generated openclaw config
        run: bun run build:openclaw:check

  publish:
    if: startsWith(github.ref, 'refs/tags/v')
    needs: verify
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

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

      - name: Ensure latest npm (trusted publishing requires >= 11.5.1)
        run: npm install -g npm@latest

      - name: Verify tag matches package.json version
        run: |
          PKG_VERSION=$(node -p "require('./package.json').version")
          TAG_VERSION="${GITHUB_REF_NAME#v}"
          if [ "$PKG_VERSION" != "$TAG_VERSION" ]; then
            echo "::error::Tag version ($TAG_VERSION) does not match package.json ($PKG_VERSION)"
            exit 1
          fi

      - run: npm publish --provenance --access public

name: Test

on:
  pull_request:
  push:
    branches:
      - main
      - master
      - 'codex/**'

permissions:
  contents: read

jobs:
  test:
    runs-on: ubuntu-latest
    env:
      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
    steps:
      - uses: actions/checkout@v4

      - uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Check dependency baseline
        run: bun run deps:check

      - name: Type check
        run: bunx tsc --noEmit

      - name: Coverage gate
        run: bun run test:coverage:ci

      - name: Verify generated openclaw config
        run: bun run build:openclaw:check

      - name: Upload coverage to Codecov
        if: ${{ env.CODECOV_TOKEN != '' }}
        uses: codecov/codecov-action@v5
        with:
          token: ${{ env.CODECOV_TOKEN }}
          files: ./coverage/lcov.info
          fail_ci_if_error: true

      - name: Skip Codecov upload (missing token)
        if: ${{ env.CODECOV_TOKEN == '' }}
        run: echo "CODECOV_TOKEN is not set; skipping Codecov upload."

node_modules
coverage
*.log
.DS_Store
.env

#!/usr/bin/env bun
import { Command } from 'commander';
import { ZodError } from 'zod';
import { CLI_TOOL_DESCRIPTOR_BY_KEY } from './src/tooling/tool-descriptors.js';

function parseInput(raw?: string): Record<string, unknown> {
  if (!raw) {
    return {};
  }

  try {
    const parsed = JSON.parse(raw);
    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
      throw new Error('Input must be a JSON object.');
    }

    return parsed as Record<string, unknown>;
  } catch (error) {
    throw new Error(`Invalid --input JSON: ${(error as Error).message}`);
  }
}

async function runCommand(domain: string, action: string, inputRaw?: string): Promise<void> {
  const key = `${domain}.${action}`;
  const descriptor = CLI_TOOL_DESCRIPTOR_BY_KEY.get(key);

  if (!descriptor) {
    throw new Error(`Unsupported command: ${key}`);
  }

  const input = parseInput(inputRaw);
  const validatedInput = descriptor.parse(input);
  const result = await descriptor.handler(validatedInput);
  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

  if (!result.success) {
    process.exitCode = 1;
  }
}

const program = new Command();
program
  .name('aelfscan-skill')
  .description('AelfScan skill CLI (search/blockchain/address/token/nft/statistics)')
  .argument('<domain>', 'search | blockchain | address | token | nft | statistics')
  .argument('<action>', 'action name under domain')
  .option('--input <json>', 'JSON input payload')
  .action(async (domain, action, options: { input?: string }) => {
    await runCommand(domain, action, options.input);
  });

program.parseAsync(process.argv).catch((error: unknown) => {
  if (error instanceof ZodError) {
    process.stderr.write(`[ERROR] Invalid input: ${error.message}\n`);
    process.exit(1);
    return;
  }

  process.stderr.write(`[ERROR] ${(error as Error).message}\n`);
  process.exit(1);
});

#!/usr/bin/env bun
import * as fs from 'node:fs';
import * as path from 'node:path';

const root = path.resolve(import.meta.dir, '..');
const lcovPath = path.join(root, 'coverage', 'lcov.info');
const outputPath = path.join(root, 'coverage', 'coverage-badge.json');

if (!fs.existsSync(lcovPath)) {
  process.stderr.write(`[ERROR] lcov not found: ${lcovPath}\n`);
  process.exit(1);
}

const lcov = fs.readFileSync(lcovPath, 'utf-8');
let linesFound = 0;
let linesHit = 0;

for (const line of lcov.split('\n')) {
  if (line.startsWith('LF:')) {
    linesFound += Number(line.slice(3)) || 0;
  }

  if (line.startsWith('LH:')) {
    linesHit += Number(line.slice(3)) || 0;
  }
}

const coverage = linesFound > 0 ? (linesHit / linesFound) * 100 : 0;
const rounded = Math.round(coverage * 100) / 100;

let color = 'red';
if (rounded >= 90) {
  color = 'brightgreen';
} else if (rounded >= 80) {
  color = 'green';
} else if (rounded >= 70) {
  color = 'yellowgreen';
} else if (rounded >= 60) {
  color = 'yellow';
} else if (rounded >= 50) {
  color = 'orange';
}

const badge = {
  schemaVersion: 1,
  label: 'coverage',
  message: `${rounded}%`,
  color,
};

fs.mkdirSync(path.dirname(outputPath), { recursive: true });
fs.writeFileSync(outputPath, `${JSON.stringify(badge, null, 2)}\n`, 'utf-8');
process.stdout.write(`[OK] Coverage badge generated: ${outputPath} (${badge.message})\n`);

#!/usr/bin/env bun
import * as fs from 'node:fs';
import * as path from 'node:path';
import { OPENCLAW_TOOL_DESCRIPTORS } from '../src/tooling/tool-descriptors.js';

const packageRoot = path.resolve(import.meta.dir, '..');
const targetPath = path.join(packageRoot, 'openclaw.json');

const openclaw = {
  name: 'aelfscan-skill',
  description: 'AelfScan explorer tools for search, blockchain, addresses, tokens, NFTs, and statistics.',
  tools: OPENCLAW_TOOL_DESCRIPTORS.map(descriptor => ({
    name: descriptor.mcpName,
    description: descriptor.description,
    command: 'bun',
    args: ['run', 'aelfscan_skill.ts', descriptor.domain, descriptor.action],
    cwd: '.',
    inputSchema: {
      type: 'object',
      properties: {},
      additionalProperties: true,
    },
  })),
};

const serialized = `${JSON.stringify(openclaw, null, 2)}\n`;
const checkMode = process.argv.includes('--check');

if (checkMode) {
  if (!fs.existsSync(targetPath)) {
    process.stderr.write(`[ERROR] ${targetPath} does not exist\n`);
    process.exit(1);
  }

  const existing = fs.readFileSync(targetPath, 'utf-8');
  if (existing !== serialized) {
    process.stderr.write('[ERROR] openclaw.json is out of date. Run `bun run build:openclaw`\n');
    process.exit(1);
  }

  process.stdout.write('[OK] openclaw.json is up to date\n');
  process.exit(0);
}

fs.writeFileSync(targetPath, serialized, 'utf-8');
process.stdout.write(`[OK] Generated ${targetPath} with ${openclaw.tools.length} tools\n`);

import {
  LOG,
  SERVER_NAME,
  generateMcpEntry,
  getPlatformPaths,
  mergeMcpConfig,
  readJsonFile,
  removeMcpEntry,
  writeJsonFile,
} from './utils.js';

export function setupClaude(opts: { configPath?: string; serverPath?: string; force?: boolean }): boolean {
  const configPath = opts.configPath || getPlatformPaths().claude;
  const entry = generateMcpEntry(opts.serverPath);

  LOG.step(`Config file: ${configPath}`);
  LOG.step(`MCP server: ${entry.args[1]}`);

  const existing = readJsonFile(configPath);
  const { config, action } = mergeMcpConfig(existing, SERVER_NAME, entry, opts.force);

  if (action === 'skipped') {
    LOG.warn(`\"${SERVER_NAME}\" already exists in Claude Desktop config.`);
    LOG.info('Use --force to overwrite.');
    return false;
  }

  writeJsonFile(configPath, config);
  LOG.success(`Claude Desktop MCP config ${action}: ${configPath}`);
  LOG.info('Restart Claude Desktop to apply changes.');
  return true;
}

export function uninstallClaude(opts: { configPath?: string }): boolean {
  const configPath = opts.configPath || getPlatformPaths().claude;
  const existing = readJsonFile(configPath);
  const { config, removed } = removeMcpEntry(existing, SERVER_NAME);

  if (!removed) {
    LOG.info(`\"${SERVER_NAME}\" not found in Claude Desktop config.`);
    return false;
  }

  writeJsonFile(configPath, config);
  LOG.success(`Removed \"${SERVER_NAME}\" from Claude Desktop config.`);
  return true;
}

import {
  LOG,
  SERVER_NAME,
  generateMcpEntry,
  getCursorProjectPath,
  getPlatformPaths,
  mergeMcpConfig,
  readJsonFile,
  removeMcpEntry,
  writeJsonFile,
} from './utils.js';

export function setupCursor(opts: {
  global?: boolean;
  configPath?: string;
  serverPath?: string;
  force?: boolean;
  projectDir?: string;
}): boolean {
  let configPath: string;
  let scope: 'global' | 'project' | 'custom';

  if (opts.configPath) {
    configPath = opts.configPath;
    scope = 'custom';
  } else if (opts.global) {
    configPath = getPlatformPaths().cursorGlobal;
    scope = 'global';
  } else {
    configPath = getCursorProjectPath(opts.projectDir);
    scope = 'project';
  }

  const entry = generateMcpEntry(opts.serverPath);

  LOG.step(`Scope: ${scope}`);
  LOG.step(`Config file: ${configPath}`);
  LOG.step(`MCP server: ${entry.args[1]}`);

  const existing = readJsonFile(configPath);
  const { config, action } = mergeMcpConfig(existing, SERVER_NAME, entry, opts.force);

  if (action === 'skipped') {
    LOG.warn(`\"${SERVER_NAME}\" already exists in Cursor ${scope} config.`);
    LOG.info('Use --force to overwrite.');
    return false;
  }

  writeJsonFile(configPath, config);
  LOG.success(`Cursor ${scope} MCP config ${action}: ${configPath}`);
  return true;
}

export function uninstallCursor(opts: { global?: boolean; configPath?: string; projectDir?: string }): boolean {
  let configPath: string;

  if (opts.configPath) {
    configPath = opts.configPath;
  } else if (opts.global) {
    configPath = getPlatformPaths().cursorGlobal;
  } else {
    configPath = getCursorProjectPath(opts.projectDir);
  }

  const existing = readJsonFile(configPath);
  const { config, removed } = removeMcpEntry(existing, SERVER_NAME);

  if (!removed) {
    LOG.info(`\"${SERVER_NAME}\" not found in Cursor config: ${configPath}`);
    return false;
  }

  writeJsonFile(configPath, config);
  LOG.success(`Removed \"${SERVER_NAME}\" from Cursor config: ${configPath}`);
  return true;
}

import * as fs from 'node:fs';
import * as path from 'node:path';
import { LOG, getPackageRoot, readJsonFile, writeJsonFile } from './utils.js';

interface OpenClawTool {
  name: string;
  description?: string;
  command?: string;
  args?: string[];
  cwd?: string;
  [key: string]: unknown;
}

function getSourceFilePath(): string {
  return path.join(getPackageRoot(), 'openclaw.json');
}

function loadSourceTools(): OpenClawTool[] {
  const sourcePath = getSourceFilePath();
  if (!fs.existsSync(sourcePath)) {
    throw new Error(`openclaw.json not found at ${sourcePath}`);
  }

  const source = readJsonFile(sourcePath);
  const tools = Array.isArray(source.tools) ? source.tools : [];
  if (!tools.length) {
    throw new Error('No tools found in openclaw.json');
  }

  return tools;
}

export function setupOpenClaw(opts: { configPath?: string; cwd?: string; force?: boolean }): boolean {
  let tools: OpenClawTool[];
  try {
    tools = loadSourceTools();
  } catch (error) {
    LOG.error((error as Error).message);
    return false;
  }

  const resolvedCwd = opts.cwd || getPackageRoot();
  const normalizedTools = tools.map(tool => ({
    ...tool,
    cwd: resolvedCwd,
  }));

  if (!opts.configPath) {
    const outputPath = path.join(process.cwd(), 'aelfscan-openclaw.json');
    writeJsonFile(outputPath, { tools: normalizedTools });
    LOG.success(`Generated standalone OpenClaw config: ${outputPath}`);
    LOG.info(`Tools count: ${normalizedTools.length}; cwd=${resolvedCwd}`);
    return true;
  }

  LOG.step(`Merging ${normalizedTools.length} tools into: ${opts.configPath}`);

  const existing = readJsonFile(opts.configPath);
  if (!Array.isArray(existing.tools)) {
    existing.tools = [];
  }

  let added = 0;
  let updated = 0;

  for (const tool of normalizedTools) {
    const index = existing.tools.findIndex((item: OpenClawTool) => item.name === tool.name);
    if (index >= 0) {
      if (opts.force) {
        existing.tools[index] = tool;
        updated += 1;
      }
      continue;
    }

    existing.tools.push(tool);
    added += 1;
  }

  writeJsonFile(opts.configPath, existing);
  LOG.success(`OpenClaw config updated: ${added} added, ${updated} updated.`);
  return true;
}

export function uninstallOpenClaw(opts: { configPath?: string }): boolean {
  if (!opts.configPath) {
    LOG.info('Provide --config-path to remove tools from an existing OpenClaw config.');
    return false;
  }

  let toolNames: Set<string>;
  try {
    toolNames = new Set(loadSourceTools().map(tool => tool.name));
  } catch (error) {
    LOG.error((error as Error).message);
    return false;
  }

  const existing = readJsonFile(opts.configPath);
  if (!Array.isArray(existing.tools)) {
    LOG.info('No tools found in target OpenClaw config.');
    return false;
  }

  const before = existing.tools.length;
  existing.tools = existing.tools.filter((tool: OpenClawTool) => !toolNames.has(tool.name));
  const removed = before - existing.tools.length;

  if (removed <= 0) {
    LOG.info('No aelfscan-skill tools found in target OpenClaw config.');
    return false;
  }

  writeJsonFile(opts.configPath, existing);
  LOG.success(`Removed ${removed} aelfscan-skill tools from OpenClaw config.`);
  return true;
}

import * as fs from 'node:fs';
import * as os from 'node:os';
import * as path from 'node:path';

export const SERVER_NAME = 'aelfscan-skill';

export interface PlatformPaths {
  claude: string;
  cursorGlobal: string;
}

export interface McpServerEntry {
  command: string;
  args: string[];
  env: Record<string, string>;
}

export function getPackageRoot(): string {
  return path.resolve(import.meta.dir, '..', '..');
}

export function getMcpServerPath(): string {
  return path.join(getPackageRoot(), 'src', 'mcp', 'server.ts');
}

export function getBunPath(): string {
  try {
    const cmd = os.platform() === 'win32' ? ['where', 'bun'] : ['which', 'bun'];
    const result = Bun.spawnSync(cmd);
    const output = result.stdout.toString().trim();
    if (output) {
      return output.split('\n')[0].trim();
    }
  } catch {
    // ignore and use fallback
  }
  return 'bun';
}

export function getPlatformPaths(): PlatformPaths {
  const home = os.homedir();
  const platform = os.platform();

  let claude: string;
  if (platform === 'darwin') {
    claude = path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
  } else if (platform === 'win32') {
    const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
    claude = path.join(appData, 'Claude', 'claude_desktop_config.json');
  } else {
    claude = path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
  }

  return {
    claude,
    cursorGlobal: path.join(home, '.cursor', 'mcp.json'),
  };
}

export function getCursorProjectPath(projectDir?: string): string {
  const baseDir = projectDir || process.cwd();
  return path.join(baseDir, '.cursor', 'mcp.json');
}

export function readJsonFile(filePath: string): any {
  try {
    if (!fs.existsSync(filePath)) {
      return {};
    }

    const text = fs.readFileSync(filePath, 'utf8');
    return JSON.parse(text);
  } catch {
    return {};
  }
}

export function writeJsonFile(filePath: string, data: any): void {
  const dir = path.dirname(filePath);
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
  }

  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
}

export function generateMcpEntry(customServerPath?: string): McpServerEntry {
  return {
    command: getBunPath(),
    args: ['run', customServerPath || getMcpServerPath()],
    env: {
      AELFSCAN_API_BASE_URL: 'https://aelfscan.io',
    },
  };
}

export function mergeMcpConfig(
  existing: any,
  serverName: string,
  entry: McpServerEntry,
  force = false,
): { config: any; action: 'created' | 'updated' | 'skipped' } {
  const config = { ...existing };
  if (!config.mcpServers) {
    config.mcpServers = {};
  }

  if (config.mcpServers[serverName] && !force) {
    return { config, action: 'skipped' };
  }

  const action = config.mcpServers[serverName] ? 'updated' : 'created';
  config.mcpServers[serverName] = entry;
  return { config, action };
}

export function removeMcpEntry(existing: any, serverName: string): { config: any; removed: boolean } {
  const config = { ...existing };
  if (!config.mcpServers || !config.mcpServers[serverName]) {
    return { config, removed: false };
  }

  delete config.mcpServers[serverName];
  return { config, removed: true };
}

export const LOG = {
  step: (message: string) => console.log(`  -> ${message}`),
  info: (message: string) => console.log(`  [INFO] ${message}`),
  success: (message: string) => console.log(`  [OK] ${message}`),
  warn: (message: string) => console.log(`  [WARN] ${message}`),
  error: (message: string) => console.error(`  [ERROR] ${message}`),
};

#!/usr/bin/env bun
import './setup.ts';

#!/usr/bin/env bun
import { Command } from 'commander';
import * as fs from 'node:fs';
import packageJson from '../package.json';
import {
  LOG,
  SERVER_NAME,
  getBunPath,
  getCursorProjectPath,
  getMcpServerPath,
  getPackageRoot,
  getPlatformPaths,
  readJsonFile,
} from './platforms/utils.js';
import { setupClaude, uninstallClaude } from './platforms/claude.js';
import { setupCursor, uninstallCursor } from './platforms/cursor.js';
import { setupOpenClaw, uninstallOpenClaw } from './platforms/openclaw.js';

const program = new Command();

program
  .name('aelfscan-setup')
  .description('Configure @aelfscan/agent-skills for Claude/Cursor/OpenClaw')
  .version(packageJson.version);

const withCommonMcpOptions = (command: Command) =>
  command
    .option('--server-path <path>', 'Custom path to MCP server.ts')
    .option('--config-path <path>', 'Custom config file path')
    .option('--force', 'Overwrite existing aelfscan-skill entry', false);

withCommonMcpOptions(
  program
    .command('claude')
    .description('Setup MCP server for Claude Desktop'),
).action(opts => {
  console.log('\nConfiguring Claude Desktop...\n');
  setupClaude({
    configPath: opts.configPath,
    serverPath: opts.serverPath,
    force: opts.force,
  });
  console.log('');
});

withCommonMcpOptions(
  program
    .command('cursor')
    .description('Setup MCP server for Cursor')
    .option('--global', 'Write to global ~/.cursor/mcp.json', false),
).action(opts => {
  console.log(`\nConfiguring Cursor (${opts.global ? 'global' : 'project'})...\n`);
  setupCursor({
    global: opts.global,
    configPath: opts.configPath,
    serverPath: opts.serverPath,
    force: opts.force,
  });
  console.log('');
});

program
  .command('openclaw')
  .description('Generate or merge OpenClaw tool configuration')
  .option('--config-path <path>', 'Merge into an existing OpenClaw config file')
  .option('--cwd <dir>', 'Working directory for OpenClaw tools')
  .option('--force', 'Overwrite existing tools with the same name', false)
  .action(opts => {
    console.log('\nConfiguring OpenClaw...\n');
    setupOpenClaw({
      configPath: opts.configPath,
      cwd: opts.cwd,
      force: opts.force,
    });
    console.log('');
  });

program
  .command('list')
  .description('Show detected config paths and setup status')
  .action(() => {
    const pkgRoot = getPackageRoot();
    const serverPath = getMcpServerPath();
    const bunPath = getBunPath();
    const paths = getPlatformPaths();
    const cursorProjectPath = getCursorProjectPath();

    console.log('\nAelfScan Skill setup status\n');
    console.log(`  Package root: ${pkgRoot}`);
    console.log(`  MCP server:   ${serverPath} ${fs.existsSync(serverPath) ? '[OK]' : '[MISSING]'}`);
    console.log(`  Bun path:     ${bunPath}`);
    console.log('');

    const claudeExists = fs.existsSync(paths.claude);
    const claude = claudeExists ? readJsonFile(paths.claude) : null;
    const claudeConfigured = Boolean(claude?.mcpServers?.[SERVER_NAME]);
    console.log(`  Claude Desktop: ${paths.claude}`);
    console.log(
      `    Config file: ${claudeExists ? 'exists' : 'not found'} | ${SERVER_NAME}: ${claudeConfigured ? 'configured' : 'not configured'}`,
    );

    const cursorGlobalExists = fs.existsSync(paths.cursorGlobal);
    const cursorGlobal = cursorGlobalExists ? readJsonFile(paths.cursorGlobal) : null;
    const cursorGlobalConfigured = Boolean(cursorGlobal?.mcpServers?.[SERVER_NAME]);
    console.log(`  Cursor (global): ${paths.cursorGlobal}`);
    console.log(
      `    Config file: ${cursorGlobalExists ? 'exists' : 'not found'} | ${SERVER_NAME}: ${cursorGlobalConfigured ? 'configured' : 'not configured'}`,
    );

    const cursorProjectExists = fs.existsSync(cursorProjectPath);
    const cursorProject = cursorProjectExists ? readJsonFile(cursorProjectPath) : null;
    const cursorProjectConfigured = Boolean(cursorProject?.mcpServers?.[SERVER_NAME]);
    console.log(`  Cursor (project): ${cursorProjectPath}`);
    console.log(
      `    Config file: ${cursorProjectExists ? 'exists' : 'not found'} | ${SERVER_NAME}: ${cursorProjectConfigured ? 'configured' : 'not configured'}`,
    );

    console.log('');
    LOG.info('Use `bun run setup claude|cursor|openclaw` to install.');
    console.log('');
  });

program
  .command('uninstall <platform>')
  .description('Remove aelfscan-skill setup from platform (claude|cursor|openclaw)')
  .option('--global', 'For cursor uninstall global config', false)
  .option('--config-path <path>', 'Custom config file path')
  .action((platform, opts) => {
    console.log(`\nRemoving setup from ${platform}...\n`);

    switch (platform) {
      case 'claude':
        uninstallClaude({ configPath: opts.configPath });
        break;
      case 'cursor':
        uninstallCursor({ global: opts.global, configPath: opts.configPath });
        break;
      case 'openclaw':
        uninstallOpenClaw({ configPath: opts.configPath });
        break;
      default:
        LOG.error(`Unknown platform: ${platform}. Supported: claude, cursor, openclaw.`);
        process.exitCode = 1;
        break;
    }

    console.log('');
  });

program.parse();

{
  "lockfileVersion": 1,
  "configVersion": 1,
  "workspaces": {
    "": {
      "name": "@aelfscan/agent-skills",
      "dependencies": {
        "@modelcontextprotocol/sdk": "^1.26.0",
        "commander": "^12.1.0",
        "zod": "^3.24.0",
      },
      "devDependencies": {
        "@types/bun": "latest",
        "ajv": "^8.17.1",
        "typescript": "^5.7.0",
      },
    },
  },
  "packages": {
    "@hono/node-server": ["@hono/node-server@1.19.9", "", { "peerDependencies": { "hono": "^4" } }, "sha512-vHL6w3ecZsky+8P5MD+eFfaGTyCeOHUIFYMGpQGbrBTSmNNoxv0if69rEZ5giu36weC5saFuznL411gRX7bJDw=="],

    "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.27.1", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-sr6GbP+4edBwFndLbM60gf07z0FQ79gaExpnsjMGePXqFcSSb7t6iscpjk9DhFhwd+mTEQrzNafGP8/iGGFYaA=="],

    "@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="],

    "@types/node": ["@types/node@25.3.1", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-hj9YIJimBCipHVfHKRMnvmHg+wfhKc0o4mTtXh9pKBjC8TLJzz0nzGmLi5UJsYAUgSvXFHgb0V2oY10DUFtImw=="],

    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],

    "ajv": ["ajv@8.18.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A=="],

    "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="],

    "body-parser": ["body-parser@2.2.2", "", { "dependencies": { "bytes": "^3.1.2", "content-type": "^1.0.5", "debug": "^4.4.3", "http-errors": "^2.0.0", "iconv-lite": "^0.7.0", "on-finished": "^2.4.1", "qs": "^6.14.1", "raw-body": "^3.0.1", "type-is": "^2.0.1" } }, "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA=="],

    "bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="],

    "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],

    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],

    "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="],

    "commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="],

    "content-disposition": ["content-disposition@1.0.1", "", {}, "sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q=="],

    "content-type": ["content-type@1.0.5", "", {}, "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="],

    "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],

    "cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="],

    "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="],

    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],

    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],

    "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="],

    "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],

    "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],

    "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],

    "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],

    "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],

    "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],

    "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="],

    "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],

    "eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="],

    "eventsource-parser": ["eventsource-parser@3.0.6", "", {}, "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg=="],

    "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="],

    "express-rate-limit": ["express-rate-limit@8.2.1", "", { "dependencies": { "ip-address": "10.0.1" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g=="],

    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],

    "fast-uri": ["fast-uri@3.1.0", "", {}, "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA=="],

    "finalhandler": ["finalhandler@2.1.1", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA=="],

    "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="],

    "fresh": ["fresh@2.0.0", "", {}, "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A=="],

    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],

    "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],

    "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],

    "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],

    "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],

    "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],

    "hono": ["hono@4.12.2", "", {}, "sha512-gJnaDHXKDayjt8ue0n8Gs0A007yKXj4Xzb8+cNjZeYsSzzwKc0Lr+OZgYwVfB0pHfUs17EPoLvrOsEaJ9mj+Tg=="],

    "http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],

    "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],

    "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],

    "ip-address": ["ip-address@10.0.1", "", {}, "sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA=="],

    "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],

    "is-promise": ["is-promise@4.0.0", "", {}, "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="],

    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],

    "jose": ["jose@6.1.3", "", {}, "sha512-0TpaTfihd4QMNwrz/ob2Bp7X04yuxJkjRGi4aKmOqwhov54i6u79oCv7T+C7lo70MKH6BesI3vscD1yb/yzKXQ=="],

    "json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],

    "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="],

    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],

    "media-typer": ["media-typer@1.1.0", "", {}, "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw=="],

    "merge-descriptors": ["merge-descriptors@2.0.0", "", {}, "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g=="],

    "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="],

    "mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="],

    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],

    "negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="],

    "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="],

    "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],

    "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],

    "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="],

    "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="],

    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],

    "path-to-regexp": ["path-to-regexp@8.3.0", "", {}, "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA=="],

    "pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="],

    "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="],

    "qs": ["qs@6.15.0", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-mAZTtNCeetKMH+pSjrb76NAM8V9a05I9aBZOHztWy/UqcJdQYNsf59vrRKWnojAT9Y+GbIvoTBC++CPHqpDBhQ=="],

    "range-parser": ["range-parser@1.2.1", "", {}, "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="],

    "raw-body": ["raw-body@3.0.2", "", { "dependencies": { "bytes": "~3.1.2", "http-errors": "~2.0.1", "iconv-lite": "~0.7.0", "unpipe": "~1.0.0" } }, "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA=="],

    "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],

    "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="],

    "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],

    "send": ["send@1.2.1", "", { "dependencies": { "debug": "^4.4.3", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "fresh": "^2.0.0", "http-errors": "^2.0.1", "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", "statuses": "^2.0.2" } }, "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ=="],

    "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="],

    "setprototypeof": ["setprototypeof@1.2.0", "", {}, "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="],

    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],

    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],

    "side-channel": ["side-channel@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", "side-channel-list": "^1.0.0", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw=="],

    "side-channel-list": ["side-channel-list@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3" } }, "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA=="],

    "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="],

    "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="],

    "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],

    "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="],

    "type-is": ["type-is@2.0.1", "", { "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw=="],

    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],

    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],

    "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],

    "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="],

    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],

    "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],

    "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],

    "zod-to-json-schema": ["zod-to-json-schema@3.25.1", "", { "peerDependencies": { "zod": "^3.25 || ^4" } }, "sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA=="],
  }
}

{
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.26.0",
    "zod": "^3.24.0"
  }
}

export * from './lib/types.js';
export * from './lib/api-types.js';
export { getConfig, resetConfigCache } from './lib/config.js';

export { search, getSearchFilters } from './src/core/search.js';

export {
  getBlocks,
  getLatestBlocks,
  getBlockDetail,
  getTransactions,
  getLatestTransactions,
  getTransactionDetail,
  getBlockchainOverview,
  getTransactionDataChart,
  getAddressDictionary,
  getLogEvents,
} from './src/core/blockchain.js';

export {
  getAccounts,
  getContracts,
  getAddressDetail,
  getAddressTokens,
  getAddressNftAssets,
  getAddressTransfers,
  getContractHistory,
  getContractEvents,
  getContractSource,
} from './src/core/address.js';

export { getTokens, getTokenDetail, getTokenTransfers, getTokenHolders } from './src/core/token.js';

export {
  getNftCollections,
  getNftCollectionDetail,
  getNftTransfers,
  getNftHolders,
  getNftInventory,
  getNftItemDetail,
  getNftItemHolders,
  getNftItemActivity,
} from './src/core/nft.js';

export {
  getDailyTransactions,
  getUniqueAddresses,
  getDailyActiveAddresses,
  getMonthlyActiveAddresses,
  getBlockProduceRate,
  getAvgBlockDuration,
  getCycleCount,
  getNodeBlockProduce,
  getDailyAvgTransactionFee,
  getDailyTxFee,
  getDailyTotalBurnt,
  getDailyElfPrice,
  getDailyDeployContract,
  getDailyBlockReward,
  getDailyAvgBlockSize,
  getTopContractCall,
  getDailyContractCall,
  getDailySupplyGrowth,
  getDailyMarketCap,
  getDailyStaked,
  getDailyHolder,
  getDailyTvl,
  getNodeCurrentProduceInfo,
  getElfSupply,
  getDailyTransactionInfo,
  getDailyActivityAddress,
  getCurrencyPrice,
  getStatisticsByMetric,
  STATISTICS_METRICS,
} from './src/core/statistics.js';

export interface ApiValidationError {
  memberNames?: string[];
  errorMessage?: string;
}

export interface ApiSuccessEnvelope<T> {
  code: string;
  message?: string;
  data: T;
}

export interface ApiErrorEnvelope {
  code: string;
  message?: string;
  data?: unknown;
  validationErrors?: ApiValidationError[];
}

export interface ApiPagedList<TItem> {
  total?: number;
  list?: TItem[];
  items?: TItem[];
  [key: string]: unknown;
}

export interface SearchFilterOption {
  filterType?: number;
  filterInfo?: string;
  searchType?: number;
  searchInfo?: string;
  [key: string]: unknown;
}

export interface SearchFiltersResponse {
  filterTypes?: SearchFilterOption[];
  searchTypes?: SearchFilterOption[];
  [key: string]: unknown;
}

export interface BlockSummary {
  blockHeight?: number;
  blockHash?: string;
  chainId?: string;
  blockTime?: string;
  txns?: number;
  [key: string]: unknown;
}

export interface TransactionSummary {
  transactionId?: string;
  blockHeight?: number;
  blockHash?: string;
  from?: string;
  to?: string;
  methodName?: string;
  status?: string;
  blockTime?: string;
  [key: string]: unknown;
}

export interface LogEvent {
  name?: string;
  indexed?: unknown[];
  nonIndexed?: unknown[];
  [key: string]: unknown;
}

export interface SearchEntity {
  symbol?: string;
  address?: string;
  blockHeight?: number;
  transactionId?: string;
  [key: string]: unknown;
}

export interface SearchResponse {
  tokens?: SearchEntity[];
  nfts?: SearchEntity[];
  accounts?: SearchEntity[];
  contracts?: SearchEntity[];
  blocks?: BlockSummary[];
  block?: BlockSummary;
  transaction?: TransactionSummary | null;
  [key: string]: unknown;
}

export interface BlockListResponse extends ApiPagedList<BlockSummary> {
  blocks?: BlockSummary[];
}

export interface BlockDetailResponse extends BlockSummary {
  transactions?: TransactionSummary[];
  [key: string]: unknown;
}

export interface TransactionListResponse extends ApiPagedList<TransactionSummary> {
  transactions?: TransactionSummary[];
}

export interface TransactionDetailResponse extends TransactionSummary {
  logEvents?: LogEvent[] | null;
  [key: string]: unknown;
}

export interface BlockchainOverviewResponse {
  transactions?: number;
  tokenPriceInUsd?: number;
  tokenDailyPriceInUsd?: number;
  tokenPriceRate24h?: number;
  [key: string]: unknown;
}

export interface TransactionChartPoint {
  start?: number;
  end?: number;
  count?: number;
  [key: string]: unknown;
}

export interface TransactionDataChartResponse {
  all?: TransactionChartPoint[];
  mainChain?: TransactionChartPoint[];
  sideChain?: TransactionChartPoint[];
  [key: string]: unknown;
}

export interface AddressDictionaryResponse {
  name?: string;
  addresses?: string[];
  [key: string]: unknown;
}

export interface LogEventsResponse {
  total?: number;
  logEvents?: LogEvent[] | null;
  [key: string]: unknown;
}

export interface AccountSummary {
  address?: string;
  balance?: number;
  txns?: number;
  [key: string]: unknown;
}

export interface ContractSummary {
  address?: string;
  contractName?: string;
  type?: string;
  txns?: number;
  [key: string]: unknown;
}

export interface AddressDetailResponse {
  address?: string;
  balance?: number;
  accountType?: string;
  [key: string]: unknown;
}

export interface AddressAssetItem {
  symbol?: string;
  balance?: number;
  amount?: string | number;
  [key: string]: unknown;
}

export interface AddressTransferItem {
  transactionId?: string;
  symbol?: string;
  from?: string;
  to?: string;
  amount?: string | number;
  [key: string]: unknown;
}

export interface ContractHistoryItem {
  transactionId?: string;
  blockHeight?: number;
  updateTime?: string;
  [key: string]: unknown;
}

export interface ContractEventItem {
  blockHeight?: number;
  transactionId?: string;
  eventName?: string;
  [key: string]: unknown;
}

export interface ContractSourceResponse {
  address?: string;
  codeHash?: string;
  version?: string;
  [key: string]: unknown;
}

export interface TokenSummary {
  symbol?: string;
  tokenName?: string;
  decimals?: number;
  supply?: string | number;
  [key: string]: unknown;
}

export interface TokenDetailResponse extends TokenSummary {
  holders?: number;
  transfers?: number;
  [key: string]: unknown;
}

export interface TokenTransferItem {
  transactionId?: string;
  from?: string;
  to?: string;
  amount?: string | number;
  [key: string]: unknown;
}

export interface TokenHolderItem {
  address?: string;
  amount?: string | number;
  percentage?: string | number;
  [key: string]: unknown;
}

export interface NftCollectionSummary {
  collectionSymbol?: string;
  collectionName?: string;
  items?: number;
  holders?: number;
  [key: string]: unknown;
}

export interface NftCollectionDetailResponse extends NftCollectionSummary {
  description?: string;
  [key: string]: unknown;
}

export interface NftTransferItem {
  transactionId?: string;
  symbol?: string;
  from?: string;
  to?: string;
  [key: string]: unknown;
}

export interface NftHolderItem {
  address?: string;
  amount?: string | number;
  [key: string]: unknown;
}

export interface NftInventoryItem {
  symbol?: string;
  owner?: string;
  [key: string]: unknown;
}

export interface NftItemDetailResponse {
  symbol?: string;
  collectionSymbol?: string;
  owner?: string;
  [key: string]: unknown;
}

export interface StatisticsSeriesPoint {
  date?: number;
  dateStr?: string;
  value?: number | string;
  [key: string]: unknown;
}

export interface StatisticsListResponse extends ApiPagedList<StatisticsSeriesPoint> {
  list?: StatisticsSeriesPoint[];
}

export interface DailyTransactionsPoint extends StatisticsSeriesPoint {
  transactionCount?: number;
  blockCount?: number;
  mergeTransactionCount?: number;
}

export interface DailyTransactionsResponse extends StatisticsListResponse {
  list?: DailyTransactionsPoint[];
}

export interface DailyTransactionInfoChain {
  transactionAvgByAllType?: number;
  transactionAvgByExcludeSystem?: number;
  [key: string]: unknown;
}

export interface DailyTransactionInfoResponse {
  mainChain?: DailyTransactionInfoChain;
  sideChain?: DailyTransactionInfoChain;
  [key: string]: unknown;
}

export interface DailyActivityAddressChain {
  max?: number;
  min?: number;
  avg?: number;
  [key: string]: unknown;
}

export interface DailyActivityAddressResponse {
  mainChain?: DailyActivityAddressChain;
  sideChain?: DailyActivityAddressChain;
  [key: string]: unknown;
}

export interface NodeCurrentProduceInfoItem {
  nodeAddress?: string;
  producedBlockCount?: number;
  expectedBlockCount?: number;
  [key: string]: unknown;
}

export interface NodeCurrentProduceInfoResponse {
  roundNumber?: number;
  list?: NodeCurrentProduceInfoItem[];
  [key: string]: unknown;
}

export interface ElfSupplyResponse {
  maxSupply?: number;
  burn?: number;
  totalSupply?: number;
  circulatingSupply?: number;
  [key: string]: unknown;
}

import { normalizeChainId } from './normalize.js';
import type { AelfscanConfig } from './types.js';

const DEFAULT_TIMEOUT_MS = 10_000;
const DEFAULT_RETRY = 1;
const DEFAULT_API_BASE_URL = 'https://aelfscan.io';
const DEFAULT_RETRY_BASE_MS = 200;
const DEFAULT_RETRY_MAX_MS = 3_000;
const DEFAULT_MAX_CONCURRENT_REQUESTS = 5;
const DEFAULT_CACHE_TTL_MS = 60_000;
const DEFAULT_CACHE_MAX_ENTRIES = 500;
const DEFAULT_MAX_RESULT_COUNT = 200;
const DEFAULT_MCP_MAX_ITEMS = 50;
const DEFAULT_MCP_MAX_CHARS = 60_000;
const DEFAULT_MCP_INCLUDE_RAW = false;

let cachedConfig: AelfscanConfig | null = null;

function toNumber(raw: string | undefined, fallback: number): number {
  if (!raw) {
    return fallback;
  }

  const value = Number(raw);
  return Number.isFinite(value) && value >= 0 ? value : fallback;
}

function toBoolean(raw: string | undefined, fallback: boolean): boolean {
  if (!raw) {
    return fallback;
  }

  const normalized = raw.trim().toLowerCase();
  if (normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on') {
    return true;
  }

  if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'off') {
    return false;
  }

  return fallback;
}

function trimSlash(input: string): string {
  return input.replace(/\/+$/, '');
}

export function getConfig(): AelfscanConfig {
  if (cachedConfig) {
    return cachedConfig;
  }

  cachedConfig = {
    apiBaseUrl: trimSlash(process.env.AELFSCAN_API_BASE_URL || DEFAULT_API_BASE_URL),
    defaultChainId: normalizeChainId(process.env.AELFSCAN_DEFAULT_CHAIN_ID || ''),
    timeoutMs: toNumber(process.env.AELFSCAN_TIMEOUT_MS, DEFAULT_TIMEOUT_MS),
    retry: Math.floor(toNumber(process.env.AELFSCAN_RETRY, DEFAULT_RETRY)),
    retryBaseMs: Math.floor(toNumber(process.env.AELFSCAN_RETRY_BASE_MS, DEFAULT_RETRY_BASE_MS)),
    retryMaxMs: Math.floor(toNumber(process.env.AELFSCAN_RETRY_MAX_MS, DEFAULT_RETRY_MAX_MS)),
    maxConcurrentRequests: Math.floor(
      toNumber(process.env.AELFSCAN_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_CONCURRENT_REQUESTS),
    ),
    cacheTtlMs: Math.floor(toNumber(process.env.AELFSCAN_CACHE_TTL_MS, DEFAULT_CACHE_TTL_MS)),
    cacheMaxEntries: Math.floor(toNumber(process.env.AELFSCAN_CACHE_MAX_ENTRIES, DEFAULT_CACHE_MAX_ENTRIES)),
    maxResultCount: Math.floor(toNumber(process.env.AELFSCAN_MAX_RESULT_COUNT, DEFAULT_MAX_RESULT_COUNT)),
    mcpMaxItems: Math.floor(toNumber(process.env.AELFSCAN_MCP_MAX_ITEMS, DEFAULT_MCP_MAX_ITEMS)),
    mcpMaxChars: Math.floor(toNumber(process.env.AELFSCAN_MCP_MAX_CHARS, DEFAULT_MCP_MAX_CHARS)),
    mcpIncludeRaw: toBoolean(process.env.AELFSCAN_MCP_INCLUDE_RAW, DEFAULT_MCP_INCLUDE_RAW),
  };

  return cachedConfig;
}

export function resetConfigCache(): void {
  cachedConfig = null;
}

import type { ToolError, ToolResult } from './types.js';

export class SkillError extends Error {
  public readonly code: string;
  public readonly details?: unknown;
  public readonly httpStatus?: number;

  constructor(code: string, message: string, details?: unknown, httpStatus?: number) {
    super(message);
    this.name = 'SkillError';
    this.code = code;
    this.details = details;
    this.httpStatus = httpStatus;
  }
}

export class HttpStatusError extends SkillError {
  constructor(status: number, body: unknown) {
    super('HTTP_ERROR', `HTTP request failed with status ${status}`, body, status);
    this.name = 'HttpStatusError';
  }
}

export function toToolError(err: unknown, fallbackCode = 'UNKNOWN_ERROR'): ToolError {
  if (err instanceof SkillError) {
    return {
      code: err.code,
      message: err.message,
      details: err.details,
      httpStatus: err.httpStatus,
    };
  }

  if (err instanceof Error) {
    return {
      code: fallbackCode,
      message: err.message,
    };
  }

  return {
    code: fallbackCode,
    message: String(err),
  };
}

export function ok<T>(traceId: string, data: T, raw?: unknown): ToolResult<T> {
  return {
    success: true,
    data,
    traceId,
    raw,
  };
}

export function fail<T>(traceId: string, err: unknown, fallbackCode = 'UNKNOWN_ERROR', raw?: unknown): ToolResult<T> {
  return {
    success: false,
    error: toToolError(err, fallbackCode),
    traceId,
    raw,
  };
}

export function requireField<T>(value: T | null | undefined, name: string): T {
  if (value === undefined || value === null || value === '') {
    throw new SkillError('INVALID_INPUT', `${name} is required`);
  }

  return value;
}

import { getConfig } from './config.js';
import { SkillError, HttpStatusError } from './errors.js';
import { serializeQuery } from './serializer.js';
import type { AelfscanEnvelope, HttpClientResult } from './types.js';

export interface HttpRequestOptions {
  method?: 'GET' | 'POST';
  path: string;
  query?: Record<string, unknown>;
  body?: unknown;
  headers?: Record<string, string>;
  traceId?: string;
  cacheTtlMs?: number;
  disableCache?: boolean;
}

const responseCache = new Map<string, { expiresAt: number; value: HttpClientResult<unknown> }>();
const pendingResolvers: Array<() => void> = [];
let activeRequests = 0;

function shouldRetry(error: unknown): boolean {
  if (!(error instanceof SkillError)) {
    return true;
  }

  if (!error.httpStatus) {
    return true;
  }

  return error.httpStatus >= 500;
}

function getRetryDelayMs(attempt: number, retryBaseMs: number, retryMaxMs: number): number {
  const exponential = Math.min(retryBaseMs * 2 ** attempt, retryMaxMs);
  const jitter = Math.floor(Math.random() * Math.max(1, Math.floor(exponential * 0.25)));
  return exponential + jitter;
}

function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function parseResponseBody(response: Response): Promise<unknown> {
  const text = await response.text();
  if (!text) {
    return null;
  }

  try {
    return JSON.parse(text);
  } catch {
    return text;
  }
}

function ensurePath(path: string): string {
  if (path.startsWith('/')) {
    return path;
  }

  return `/${path}`;
}

async function acquireSlot(limit: number): Promise<() => void> {
  if (limit <= 0) {
    return () => {};
  }

  if (activeRequests < limit) {
    activeRequests += 1;
    return releaseSlot;
  }

  await new Promise<void>((resolve) => pendingResolvers.push(resolve));
  activeRequests += 1;
  return releaseSlot;
}

function releaseSlot(): void {
  activeRequests = Math.max(0, activeRequests - 1);
  const next = pendingResolvers.shift();
  if (next) {
    next();
  }
}

function getCacheTtlMs(method: 'GET' | 'POST', path: string, options: HttpRequestOptions): number {
  const config = getConfig();

  if (options.disableCache) {
    return 0;
  }

  if (options.cacheTtlMs !== undefined) {
    return Math.max(0, options.cacheTtlMs);
  }

  if (method === 'GET' && path.startsWith('/api/app/statistics/')) {
    return Math.max(0, config.cacheTtlMs);
  }

  return 0;
}

function getCacheKey(method: 'GET' | 'POST', url: string): string {
  return `${method}:${url}`;
}

function getCachedValue<T>(cacheKey: string): HttpClientResult<T> | null {
  const cached = responseCache.get(cacheKey);
  if (!cached) {
    return null;
  }

  if (cached.expiresAt <= Date.now()) {
    responseCache.delete(cacheKey);
    return null;
  }

  // Keep most recently used cache item at the tail.
  responseCache.delete(cacheKey);
  responseCache.set(cacheKey, cached);
  return cached.value as HttpClientResult<T>;
}

function setCachedValue(cacheKey: string, value: HttpClientResult<unknown>, expiresAt: number, maxEntries: number): void {
  if (maxEntries <= 0) {
    return;
  }

  if (responseCache.has(cacheKey)) {
    responseCache.delete(cacheKey);
  }

  responseCache.set(cacheKey, { expiresAt, value });

  while (responseCache.size > maxEntries) {
    const oldest = responseCache.keys().next().value;
    if (oldest === undefined) {
      break;
    }
    responseCache.delete(oldest);
  }
}

export function resetHttpClientState(): void {
  responseCache.clear();
  activeRequests = 0;
  while (pendingResolvers.length > 0) {
    const next = pendingResolvers.shift();
    if (next) {
      next();
    }
  }
}

export async function request<T>(options: HttpRequestOptions): Promise<HttpClientResult<T>> {
  const config = getConfig();
  const method = options.method || 'GET';
  const path = ensurePath(options.path);
  const queryString = serializeQuery(options.query);
  const url = `${config.apiBaseUrl}${path}${queryString ? `?${queryString}` : ''}`;
  const traceId = options.traceId;
  const cacheTtlMs = getCacheTtlMs(method, path, options);
  const cacheMaxEntries = Math.max(0, config.cacheMaxEntries);
  const cacheKey = getCacheKey(method, url);

  if (cacheTtlMs > 0 && cacheMaxEntries > 0 && method === 'GET') {
    const cached = getCachedValue<T>(cacheKey);
    if (cached) {
      return cached;
    }
  }

  let lastError: unknown;

  for (let attempt = 0; attempt <= config.retry; attempt += 1) {
    const releaseSlotHandle = await acquireSlot(config.maxConcurrentRequests);
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), config.timeoutMs);

    try {
      const response = await fetch(url, {
        method,
        signal: controller.signal,
        headers: {
          Accept: 'application/json, text/plain; q=0.9',
          'Content-Type': 'application/json',
          ...(traceId ? { 'X-Trace-Id': traceId } : {}),
          ...(options.headers || {}),
        },
        body: options.body === undefined ? undefined : JSON.stringify(options.body),
      });

      const rawBody = await parseResponseBody(response);

      if (!response.ok) {
        throw new HttpStatusError(response.status, rawBody);
      }

      const envelope = rawBody as AelfscanEnvelope<T>;
      if (envelope && typeof envelope === 'object' && 'code' in envelope) {
        if (envelope.code && envelope.code !== '20000') {
          throw new SkillError('API_BUSINESS_ERROR', envelope.message || 'Aelfscan business error', envelope);
        }

        const successResult = {
          data: (envelope.data as T) ?? ({} as T),
          raw: envelope,
        };

        if (cacheTtlMs > 0 && cacheMaxEntries > 0 && method === 'GET') {
          setCachedValue(cacheKey, successResult as HttpClientResult<unknown>, Date.now() + cacheTtlMs, cacheMaxEntries);
        }

        return successResult;
      }

      const successResult = {
        data: rawBody as T,
        raw: rawBody,
      };

      if (cacheTtlMs > 0 && cacheMaxEntries > 0 && method === 'GET') {
        setCachedValue(cacheKey, successResult as HttpClientResult<unknown>, Date.now() + cacheTtlMs, cacheMaxEntries);
      }

      return successResult;
    } catch (error) {
      lastError = error;
      if (attempt < config.retry && shouldRetry(error)) {
        const delayMs = getRetryDelayMs(attempt, config.retryBaseMs, config.retryMaxMs);
        await sleep(delayMs);
        continue;
      }
      break;
    } finally {
      clearTimeout(timeout);
      releaseSlotHandle();
    }
  }

  throw lastError;
}