Tavily Web

# Tavily API Key Configuration
# Get your API key from: https://app.tavily.com/home

TAVILY_API_KEY=your_api_key_here

#!/usr/bin/env node

/**
 * Tavily API Helper Script
 * Provides a small CLI wrapper around Tavily endpoints for skill integration.
 *
 * Usage:
 *   node tavily-api.js <search|extract|crawl|map|research> [<json-string>]
 *   cat payload.json | node tavily-api.js search
 *   node tavily-api.js search --file ./payload.json
 */

const https = require('https');
const fs = require('fs');
const path = require('path');

const API_BASE = 'https://api.tavily.com';

function loadApiKey() {
  if (process.env.TAVILY_API_KEY) {
    return process.env.TAVILY_API_KEY;
  }

  const envPath = path.join(__dirname, '..', '.env');
  if (!fs.existsSync(envPath)) {
    return null;
  }

  const envContent = fs.readFileSync(envPath, 'utf8');
  const match = envContent.match(/TAVILY_API_KEY\s*=\s*(.+)/);
  if (!match) {
    return null;
  }

  return match[1].trim().replace(/^[\"']|[\"']$/g, '');
}

function usage() {
  const cmd = path.basename(process.argv[1] || 'tavily-api.js');
  console.error(
    [
      'Usage:',
      `  node ${cmd} <search|extract|crawl|map|research> [<json-string>]`,
      `  cat payload.json | node ${cmd} search`,
      `  node ${cmd} search --file ./payload.json`,
      '',
      'Env:',
      '  TAVILY_API_KEY (env var) or .env file next to this script',
    ].join('\n'),
  );
}

function readStdin() {
  return new Promise((resolve, reject) => {
    let data = '';
    process.stdin.setEncoding('utf8');
    process.stdin.on('data', (chunk) => {
      data += chunk;
    });
    process.stdin.on('end', () => resolve(data));
    process.stdin.on('error', reject);
  });
}

async function readPayload(args) {
  const fileFlagIndex = args.findIndex((arg) => arg === '--file');
  if (fileFlagIndex !== -1) {
    const filePath = args[fileFlagIndex + 1];
    if (!filePath) {
      throw new Error('Missing value for --file');
    }
    const content = fs.readFileSync(filePath, 'utf8');
    return JSON.parse(content);
  }

  const dataFlagIndex = args.findIndex((arg) => arg === '--data');
  if (dataFlagIndex !== -1) {
    const json = args[dataFlagIndex + 1];
    if (!json) {
      throw new Error('Missing value for --data');
    }
    return JSON.parse(json);
  }

  if (args[0] && !args[0].startsWith('-')) {
    return JSON.parse(args[0]);
  }

  if (process.stdin.isTTY) {
    throw new Error('No payload provided (pass JSON arg, --data, --file, or pipe via stdin)');
  }

  const stdin = await readStdin();
  if (!stdin.trim()) {
    throw new Error('Empty stdin payload');
  }
  return JSON.parse(stdin);
}

function validatePayload(command, payload) {
  const required = {
    search: 'query',
    extract: 'urls',
    crawl: 'url',
    map: 'url',
    research: 'input'
  };

  const field = required[command];
  if (field && !payload[field]) {
    throw new Error(`Missing required field: '${field}'`);
  }
}

function postJson(endpointPath, apiKey, payload) {
  return new Promise((resolve, reject) => {
    const body = JSON.stringify(payload);
    const url = new URL(endpointPath, API_BASE);

    const req = https.request(
      url,
      {
        method: 'POST',
        headers: {
          Authorization: `Bearer ${apiKey}`,
          'Content-Type': 'application/json',
          'Content-Length': Buffer.byteLength(body),
          'User-Agent': 'Tavily-Skill/1.0',
        },
        timeout: 60_000,
      },
      (res) => {
        let data = '';
        res.setEncoding('utf8');
        res.on('data', (chunk) => {
          data += chunk;
        });
        res.on('end', () => {
          const ok = res.statusCode && res.statusCode >= 200 && res.statusCode < 300;
          if (!ok) {
            reject(new Error(`API Error ${res.statusCode}: ${data}`));
            return;
          }

          try {
            resolve(JSON.parse(data));
          } catch {
            resolve(data);
          }
        });
      },
    );

    req.on('error', reject);
    req.on('timeout', () => {
      req.destroy(new Error('Request timed out'));
    });

    req.write(body);
    req.end();
  });
}

const ENDPOINT_BY_COMMAND = {
  search: '/search',
  extract: '/extract',
  crawl: '/crawl',
  map: '/map',
  research: '/research',
};

(async () => {
  const command = process.argv[2];
  if (!command || command === '--help' || command === '-h') {
    usage();
    process.exit(command ? 0 : 1);
  }

  const endpoint = ENDPOINT_BY_COMMAND[command];
  if (!endpoint) {
    usage();
    process.exit(1);
  }

  const apiKey = loadApiKey();
  if (!apiKey) {
    console.error('Missing Tavily API key: set TAVILY_API_KEY or create .env next to tavily-api.js');
    process.exit(1);
  }

  try {
    const args = process.argv.slice(3);
    const outputIndex = args.findIndex(arg => arg === '--output');
    const outputFile = outputIndex !== -1 ? args[outputIndex + 1] : null;
    const payloadArgs = outputFile ? args.filter((_, i) => i !== outputIndex && i !== outputIndex + 1) : args;

    const payload = await readPayload(payloadArgs);
    validatePayload(command, payload);

    const result = await postJson(endpoint, apiKey, payload);
    const output = JSON.stringify(result, null, 2);

    if (outputFile) {
      fs.writeFileSync(outputFile, output, 'utf8');
      console.error(`Results saved to: ${outputFile}`);
    } else {
      console.log(output);
    }
  } catch (error) {
    console.error(`Error: ${error.message}`);
    process.exit(1);
  }
})();