curl-command-generator

仓库: patricio0312rev/skills
安装量: 52
排名: #14317

安装

npx skills add https://github.com/patricio0312rev/skills --skill curl-command-generator

cURL Command Generator

Generate ready-to-run cURL commands for quick API testing from the command line.

Core Workflow Scan routes: Find all API route definitions Extract metadata: Methods, paths, params, bodies Generate commands: Create cURL commands with flags Add authentication: Bearer, Basic, API Key headers Include examples: Request bodies with sample data Output options: Markdown, shell script, or plain text Basic cURL Syntax

GET request

curl -X GET "http://localhost:3000/api/users"

POST with JSON body

curl -X POST "http://localhost:3000/api/users" \ -H "Content-Type: application/json" \ -d '{"name": "John", "email": "john@example.com"}'

With authentication

curl -X GET "http://localhost:3000/api/users" \ -H "Authorization: Bearer YOUR_TOKEN"

With query parameters

curl -X GET "http://localhost:3000/api/users?page=1&limit=10"

Show response headers

curl -i -X GET "http://localhost:3000/api/users"

Verbose output

curl -v -X GET "http://localhost:3000/api/users"

Generator Script // scripts/generate-curl.ts import * as fs from "fs";

interface RouteInfo { method: string; path: string; name: string; description?: string; body?: object; queryParams?: { name: string; value: string }[]; auth?: boolean; }

interface CurlOptions { baseUrl: string; authHeader?: string; verbose?: boolean; showHeaders?: boolean; format?: "markdown" | "shell" | "plain"; }

function generateCurlCommand(route: RouteInfo, options: CurlOptions): string { const parts: string[] = ["curl"];

// Add flags if (options.verbose) { parts.push("-v"); } if (options.showHeaders) { parts.push("-i"); }

// Method parts.push(-X ${route.method});

// URL with query params let url = ${options.baseUrl}${route.path};

// Replace path params with placeholders url = url.replace(/:(\w+)/g, "{$1}");

// Add query params if (route.queryParams?.length) { const queryString = route.queryParams .map((p) => ${p.name}=${p.value}) .join("&"); url += ?${queryString}; }

parts.push("${url}");

// Headers if (["POST", "PUT", "PATCH"].includes(route.method)) { parts.push('-H "Content-Type: application/json"'); }

if (route.auth && options.authHeader) { parts.push(-H "${options.authHeader}"); }

// Request body if (route.body && ["POST", "PUT", "PATCH"].includes(route.method)) { const bodyJson = JSON.stringify(route.body); parts.push(-d '${bodyJson}'); }

return parts.join(" \\n "); }

function generateCurlCommands( routes: RouteInfo[], options: CurlOptions ): string { const lines: string[] = [];

if (options.format === "markdown") { lines.push("# API cURL Commands"); lines.push(""); lines.push(Base URL: \${options.baseUrl}`); lines.push(""); } else if (options.format === "shell") { lines.push("#!/bin/bash"); lines.push(""); lines.push(BASE_URL="${options.baseUrl}"`); lines.push('AUTH_TOKEN="${AUTH_TOKEN:-your-token-here}"'); lines.push(""); }

// Group by resource const groupedRoutes = groupRoutesByResource(routes);

for (const [resource, resourceRoutes] of Object.entries(groupedRoutes)) { if (options.format === "markdown") { lines.push(## ${capitalize(resource)}); lines.push(""); } else if (options.format === "shell") { lines.push(# ${capitalize(resource)}); lines.push(""); }

for (const route of resourceRoutes) {
  if (options.format === "markdown") {
    lines.push(`### ${route.name}`);
    if (route.description) {
      lines.push(route.description);
    }
    lines.push("");
    lines.push("```bash");
  } else {
    lines.push(`# ${route.name}`);
  }

  lines.push(generateCurlCommand(route, options));

  if (options.format === "markdown") {
    lines.push("```");
  }
  lines.push("");
}

}

return lines.join("\n"); }

function groupRoutesByResource( routes: RouteInfo[] ): Record { const groups: Record = {};

for (const route of routes) { const parts = route.path.split("/").filter(Boolean); const resource = parts[0] || "api";

if (!groups[resource]) {
  groups[resource] = [];
}
groups[resource].push(route);

}

return groups; }

function capitalize(str: string): string { return str.charAt(0).toUpperCase() + str.slice(1); }

Complete Example Output (Markdown)

API cURL Commands

Base URL: http://localhost:3000/api

Authentication

Login

```bash curl -X POST "http://localhost:3000/api/auth/login" \ -H "Content-Type: application/json" \ -d '{"email": "user@example.com", "password": "password123"}'

Register curl -X POST "http://localhost:3000/api/auth/register" \ -H "Content-Type: application/json" \ -d '{"name": "New User", "email": "new@example.com", "password": "securepass123"}'

Users List Users curl -X GET "http://localhost:3000/api/users?page=1&limit=10" \ -H "Authorization: Bearer YOUR_TOKEN"

Get User by ID curl -X GET "http://localhost:3000/api/users/{id}" \ -H "Authorization: Bearer YOUR_TOKEN"

Create User curl -X POST "http://localhost:3000/api/users" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer YOUR_TOKEN" \ -d '{"name": "John Doe", "email": "john@example.com", "role": "user"}'

Update User curl -X PUT "http://localhost:3000/api/users/{id}" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer YOUR_TOKEN" \ -d '{"name": "John Updated", "email": "john.updated@example.com"}'

Delete User curl -X DELETE "http://localhost:3000/api/users/{id}" \ -H "Authorization: Bearer YOUR_TOKEN"

Shell Script Output

```bash

!/bin/bash

api-commands.sh

BASE_URL="${BASE_URL:-http://localhost:3000/api}" AUTH_TOKEN="${AUTH_TOKEN:-your-token-here}"

Authentication

Login

login() { curl -X POST "${BASE_URL}/auth/login" \ -H "Content-Type: application/json" \ -d "{\"email\": \"$1\", \"password\": \"$2\"}" }

Users

List Users

list_users() { local page="${1:-1}" local limit="${2:-10}" curl -X GET "${BASE_URL}/users?page=${page}&limit=${limit}" \ -H "Authorization: Bearer ${AUTH_TOKEN}" }

Get User by ID

get_user() { curl -X GET "${BASE_URL}/users/$1" \ -H "Authorization: Bearer ${AUTH_TOKEN}" }

Create User

create_user() { curl -X POST "${BASE_URL}/users" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer ${AUTH_TOKEN}" \ -d "$1" }

Update User

update_user() { curl -X PUT "${BASE_URL}/users/$1" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer ${AUTH_TOKEN}" \ -d "$2" }

Delete User

delete_user() { curl -X DELETE "${BASE_URL}/users/$1" \ -H "Authorization: Bearer ${AUTH_TOKEN}" }

Usage examples:

./api-commands.sh

login user@example.com password123

list_users 1 10

get_user abc123

create_user '{"name": "John", "email": "john@example.com"}'

update_user abc123 '{"name": "John Updated"}'

delete_user abc123

Execute command if provided

if [ -n "$1" ]; then "$@" fi

Advanced cURL Flags

Common useful flags

curl -X GET "http://localhost:3000/api/users" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer TOKEN" \ -i # Include response headers -v # Verbose output -s # Silent mode (no progress) -S # Show errors in silent mode -o response.json # Save response to file -w "\n%{http_code}\n" # Print status code --connect-timeout 5 # Connection timeout --max-time 30 # Max request time -L # Follow redirects -k # Skip SSL verification (dev only)

Pretty print JSON response

curl -s "http://localhost:3000/api/users" | jq .

Save cookies and use them

curl -c cookies.txt -b cookies.txt "http://localhost:3000/api/auth/login"

Upload file

curl -X POST "http://localhost:3000/api/upload" \ -H "Authorization: Bearer TOKEN" \ -F "file=@./document.pdf"

Form data

curl -X POST "http://localhost:3000/api/form" \ -d "name=John&email=john@example.com"

With timing info

curl -X GET "http://localhost:3000/api/users" \ -w "\nDNS: %{time_namelookup}s\nConnect: %{time_connect}s\nTotal: %{time_total}s\n"

Environment-Specific Commands

.env.curl

Development

DEV_URL="http://localhost:3000/api" DEV_TOKEN=""

Staging

STAGING_URL="https://staging-api.example.com" STAGING_TOKEN=""

Production

PROD_URL="https://api.example.com" PROD_TOKEN=""

!/bin/bash

curl-env.sh

set -a source .env.curl set +a

ENV="${1:-dev}"

case $ENV in dev) BASE_URL="$DEV_URL" AUTH_TOKEN="$DEV_TOKEN" ;; staging) BASE_URL="$STAGING_URL" AUTH_TOKEN="$STAGING_TOKEN" ;; prod) BASE_URL="$PROD_URL" AUTH_TOKEN="$PROD_TOKEN" ;; esac

export BASE_URL AUTH_TOKEN echo "Using $ENV environment: $BASE_URL"

CLI Script

!/usr/bin/env node

// scripts/curl-gen.ts import * as fs from "fs"; import { program } from "commander";

program .name("curl-gen") .description("Generate cURL commands from API routes") .option("-f, --framework ", "Framework type", "express") .option("-s, --source ", "Source directory", "./src") .option("-o, --output ", "Output file", "./docs/api-curl.md") .option("-b, --base-url ", "Base URL", "http://localhost:3000/api") .option("--format ", "Output format (markdown|shell|plain)", "markdown") .option("-v, --verbose", "Include verbose flag") .parse();

const options = program.opts();

async function main() { const routes = await scanRoutes(options.framework, options.source);

const content = generateCurlCommands(routes, { baseUrl: options.baseUrl, authHeader: "Authorization: Bearer YOUR_TOKEN", verbose: options.verbose, format: options.format, });

fs.writeFileSync(options.output, content); console.log(Generated ${options.output} with ${routes.length} commands); }

main();

Makefile Integration

Makefile

BASE_URL ?= http://localhost:3000/api AUTH_TOKEN ?= your-token-here

.PHONY: api-login api-users api-user api-create-user

api-login: @curl -X POST "$(BASE_URL)/auth/login" \ -H "Content-Type: application/json" \ -d '{"email": "$(EMAIL)", "password": "$(PASSWORD)"}'

api-users: @curl -X GET "$(BASE_URL)/users" \ -H "Authorization: Bearer $(AUTH_TOKEN)"

api-user: @curl -X GET "$(BASE_URL)/users/$(ID)" \ -H "Authorization: Bearer $(AUTH_TOKEN)"

api-create-user: @curl -X POST "$(BASE_URL)/users" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $(AUTH_TOKEN)" \ -d '$(DATA)'

Usage:

make api-login EMAIL=user@example.com PASSWORD=pass123

make api-users AUTH_TOKEN=xxx

make api-user ID=123 AUTH_TOKEN=xxx

make api-create-user DATA='{"name":"John"}' AUTH_TOKEN=xxx

Best Practices Use variables: Replace tokens and IDs with placeholders Pretty print: Pipe to jq for readable JSON output Save responses: Use -o to save responses for analysis Check status: Use -w "%{http_code}" to see status codes Silent mode: Use -sS for scripts to hide progress Document examples: Include realistic sample data Version control: Commit curl docs to repository Environment files: Use env files for different environments Output Checklist All routes converted to cURL commands Path parameters use {param} placeholder syntax Query parameters included in URL Request bodies with sample JSON data Content-Type header for POST/PUT/PATCH Authorization header with placeholder token Commands grouped by resource Output in requested format (markdown/shell/plain) Proper escaping for shell special characters

← 返回排行榜