HTTP REST Client with Retry Logic (javascript, written by Gemini Code Assist)

Gemini Code Assist wrote this javascript project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: HTTP REST Client with Retry Logic

Write a program that sends HTTP requests to REST APIs with configurable retry logic, response validation, request chaining, and comprehensive logging of request/response cycles.

FUNCTIONAL REQUIREMENTS:
- Accept a URL as a command-line argument with --method flag (GET, POST, PUT, PATCH, DELETE; default: GET)
- Support sending request body via --data flag (JSON string) or --file flag (read body from a file)
- Support custom headers via --header flag (repeatable, e.g., --header "Content-Type: application/json" --header "Authorization: Bearer token")
- Implement configurable retry logic: --retries flag (default 3), --backoff flag for backoff strategy (linear, exponential; default: exponential), --retry-delay flag for initial delay in seconds (default 1)
- Retry only on configurable HTTP status codes via --retry-on flag (default: 429, 500, 502, 503, 504)
- Support request timeout via --timeout flag (default 30 seconds)
- Support request chaining from a JSON recipe file via --chain flag: execute a sequence of requests where later requests can reference values from earlier responses using JSONPath expressions
- Log complete request/response cycles: method, URL, headers, body, status code, response headers, response body, timing, and retry attempts
- Support response validation via --expect-status flag (e.g., --expect-status 200) and --expect-json flag (JSONPath expression that must exist in the response)
- Print formatted response to console: status code, headers, and pretty-printed body (auto-detect JSON and format it)
- Save the full request/response log as JSON with --output flag (default: request_log.json)
- If no URL is given, demonstrate the client by sending requests to a public test API (httpbin.org or similar), showing GET, POST with JSON body, retry on simulated failure, and a simple request chain
- Handle errors: connection refused, DNS failure, SSL errors, malformed JSON responses, and redirect loops

Create a complete JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

{
  "name": "rest-client",
  "version": "1.0.0",
  "description": "Reliable REST client with retry logic",
  "main": "rest_client.js",
  "engines": {
    "node": ">=20.0.0"
  },
  "dependencies": {
    "axios": "1.6.7",
    "axios-retry": "4.0.0",
    "yargs": "17.7.2"
  },
  "scripts": {
    "start": "node rest_client.js"
  }
}

# HTTP REST Client (JavaScript)

A tool for making API requests with automatic retry logic using Axios.

## Setup Instructions

1. Ensure Node.js 20+ (LTS) is installed.
2. Install dependencies:
   ```bash
   npm install
   ```

## Run Commands

- **GET Request**:
  ```bash
  node rest_client.js https://httpbin.org/get
  ```
- **POST Request**:
  ```bash
  node rest_client.js https://httpbin.org/post --method POST --data '{"foo":"bar"}'
  ```

const axios = require('axios');
const axiosRetry = require('axios-retry').default;
const yargs = require('yargs/yargs');
const { hideBin } = require('yargs/helpers');

// Configure automatic retries
axiosRetry(axios, { 
    retries: 3, 
    retryDelay: axiosRetry.exponentialDelay,
    retryCondition: (error) => {
        return axiosRetry.isNetworkOrIdempotentRequestError(error) || 
               (error.response && [429, 500, 502, 503, 504].includes(error.response.status));
    }
});

const argv = yargs(hideBin(process.argv))
    .option('method', { default: 'GET' })
    .option('data', { help: 'JSON data' })
    .argv;

const url = argv._[0] || 'https://httpbin.org/get';

async function run() {
    try {
        console.log(`Sending ${argv.method} request to ${url}...`);
        
        const response = await axios({
            method: argv.method,
            url: url,
            data: argv.data ? JSON.parse(argv.data) : null,
            timeout: 30000
        });

        console.log(`Status: ${response.status} ${response.statusText}`);
        console.log('Response Body:');
        console.log(JSON.stringify(response.data, null, 4));
    } catch (e) {
        if (e.response) {
            console.error(`Status: ${e.response.status}`);
            console.error(JSON.stringify(e.response.data, null, 4));
        } else {
            console.error(`Error: ${e.message}`);
        }
    }
}

run();