@qodalis/cli-curl 0.0.4 → 2.0.0-beta.10

package/package.json

@@ -1,44 +1,37 @@
 {
   "name": "@qodalis/cli-curl",
-  "version": "0.0.4",
-  "description": "Provide utility functions for the library curl",
+  "version": "2.0.0-beta.10",
+  "description": "@qodalis/cli extension for making HTTP requests via a curl-like interface.",
   "author": "Nicolae Lupei, Qodalis Solutions",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/qodalis-solutions/angular-web-cli"
+    "url": "https://github.com/qodalis-solutions/web-cli"
   },
   "homepage": "https://qodalis.com",
   "keywords": [
-    "angular",
     "cli",
     "qodalis",
     "terminal",
-    "curl"
+    "curl",
+    "http",
+    "requests",
+    "fetch"
   ],
-  "umd": "./umd/index.js",
-  "unpkg": "./umd/index.js",
-  "peerDependencies": {
-    "@angular/common": "^16.2.0",
-    "@angular/core": "^16.2.0"
-  },
+  "umd": "./umd/index.global.js",
+  "unpkg": "./umd/index.global.js",
   "dependencies": {
-    "tslib": "^2.3.0",
-    "@qodalis/cli-core": "^0.0.16",
-    "@qodalis/angular-cli": "^1.0.37"
+    "@qodalis/cli-core": "2.0.0-beta.10"
   },
   "sideEffects": false,
-  "module": "fesm2022/qodalis-cli-curl.mjs",
-  "typings": "index.d.ts",
+  "main": "./public-api.js",
+  "module": "./public-api.mjs",
+  "types": "./public-api.d.ts",
   "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
     ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/qodalis-cli-curl.mjs",
-      "esm": "./esm2022/qodalis-cli-curl.mjs",
-      "default": "./fesm2022/qodalis-cli-curl.mjs"
+      "types": "./public-api.d.ts",
+      "import": "./public-api.mjs",
+      "require": "./public-api.js"
     }
   }
-}
+}

package/public-api.d.mts

@@ -0,0 +1,87 @@
+import * as _qodalis_cli_core from '@qodalis/cli-core';
+import { ICliCommandProcessor, CliProcessorMetadata, ICliConfigurationOption, CliProcessCommand, ICliExecutionContext, ICliModule } from '@qodalis/cli-core';
+
+interface CurlRequestOptions {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    followRedirects: boolean;
+}
+interface CurlResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    timing: number;
+    url: string;
+    redirected: boolean;
+}
+declare function inferMethod(explicitMethod?: string, hasBody?: boolean): string;
+declare function parseHeaders(headerArgs: string | string[] | undefined): Record<string, string>;
+declare function resolveBody(data?: string, dataRaw?: string): string | undefined;
+declare function isJsonBody(body?: string): boolean;
+declare function buildFetchOptions(options: CurlRequestOptions): RequestInit;
+declare function formatResponseBody(body: string, pretty: boolean): string;
+declare function rewriteUrlToProxy(originalUrl: string): string;
+declare function buildCurlEquivalent(url: string, method: string, headers: Record<string, string>, body?: string): string;
+declare function extractResponseHeaders(response: Response): Record<string, string>;
+
+declare class CliCurlCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    version: string;
+    valueRequired: boolean;
+    metadata?: CliProcessorMetadata;
+    configurationOptions?: ICliConfigurationOption[];
+    parameters: ({
+        name: string;
+        aliases: string[];
+        type: "string";
+        description: string;
+        required: boolean;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        aliases: string[];
+        type: "array";
+        description: string;
+        required: boolean;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        type: "string";
+        description: string;
+        required: boolean;
+        aliases?: undefined;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        aliases: string[];
+        type: "boolean";
+        description: string;
+        required: boolean;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        type: "boolean";
+        description: string;
+        required: boolean;
+        aliases?: undefined;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        type: "number";
+        description: string;
+        required: boolean;
+        defaultValue: string;
+        aliases?: undefined;
+    })[];
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    initialize(_context: ICliExecutionContext): Promise<void>;
+}
+
+declare const curlModule: ICliModule;
+
+export { CliCurlCommandProcessor, type CurlRequestOptions, type CurlResponse, buildCurlEquivalent, buildFetchOptions, curlModule, extractResponseHeaders, formatResponseBody, inferMethod, isJsonBody, parseHeaders, resolveBody, rewriteUrlToProxy };

package/public-api.d.ts

@@ -1,2 +1,87 @@
-export * from './lib/cli-curl.module';
-export * from './lib/processors/cli-curl-command-processor';
+import * as _qodalis_cli_core from '@qodalis/cli-core';
+import { ICliCommandProcessor, CliProcessorMetadata, ICliConfigurationOption, CliProcessCommand, ICliExecutionContext, ICliModule } from '@qodalis/cli-core';
+
+interface CurlRequestOptions {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    followRedirects: boolean;
+}
+interface CurlResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    timing: number;
+    url: string;
+    redirected: boolean;
+}
+declare function inferMethod(explicitMethod?: string, hasBody?: boolean): string;
+declare function parseHeaders(headerArgs: string | string[] | undefined): Record<string, string>;
+declare function resolveBody(data?: string, dataRaw?: string): string | undefined;
+declare function isJsonBody(body?: string): boolean;
+declare function buildFetchOptions(options: CurlRequestOptions): RequestInit;
+declare function formatResponseBody(body: string, pretty: boolean): string;
+declare function rewriteUrlToProxy(originalUrl: string): string;
+declare function buildCurlEquivalent(url: string, method: string, headers: Record<string, string>, body?: string): string;
+declare function extractResponseHeaders(response: Response): Record<string, string>;
+
+declare class CliCurlCommandProcessor implements ICliCommandProcessor {
+    command: string;
+    description: string;
+    author: _qodalis_cli_core.ICliCommandAuthor;
+    version: string;
+    valueRequired: boolean;
+    metadata?: CliProcessorMetadata;
+    configurationOptions?: ICliConfigurationOption[];
+    parameters: ({
+        name: string;
+        aliases: string[];
+        type: "string";
+        description: string;
+        required: boolean;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        aliases: string[];
+        type: "array";
+        description: string;
+        required: boolean;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        type: "string";
+        description: string;
+        required: boolean;
+        aliases?: undefined;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        aliases: string[];
+        type: "boolean";
+        description: string;
+        required: boolean;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        type: "boolean";
+        description: string;
+        required: boolean;
+        aliases?: undefined;
+        defaultValue?: undefined;
+    } | {
+        name: string;
+        type: "number";
+        description: string;
+        required: boolean;
+        defaultValue: string;
+        aliases?: undefined;
+    })[];
+    processCommand(command: CliProcessCommand, context: ICliExecutionContext): Promise<void>;
+    writeDescription(context: ICliExecutionContext): void;
+    initialize(_context: ICliExecutionContext): Promise<void>;
+}
+
+declare const curlModule: ICliModule;
+
+export { CliCurlCommandProcessor, type CurlRequestOptions, type CurlResponse, buildCurlEquivalent, buildFetchOptions, curlModule, extractResponseHeaders, formatResponseBody, inferMethod, isJsonBody, parseHeaders, resolveBody, rewriteUrlToProxy };

package/public-api.js

@@ -0,0 +1,399 @@
+'use strict';
+
+var cliCore = require('@qodalis/cli-core');
+
+// src/lib/utilities/index.ts
+var VALID_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+function inferMethod(explicitMethod, hasBody) {
+  if (explicitMethod) {
+    const upper = explicitMethod.toUpperCase();
+    if (!VALID_METHODS.includes(upper)) {
+      throw new Error(`Invalid HTTP method: ${explicitMethod}. Valid methods: ${VALID_METHODS.join(", ")}`);
+    }
+    return upper;
+  }
+  return hasBody ? "POST" : "GET";
+}
+function parseHeaders(headerArgs) {
+  if (!headerArgs) return {};
+  const arr = Array.isArray(headerArgs) ? headerArgs : [headerArgs];
+  const result = {};
+  for (const header of arr) {
+    const colonIndex = header.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = header.substring(0, colonIndex).trim();
+    const value = header.substring(colonIndex + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+function resolveBody(data, dataRaw) {
+  if (dataRaw != null) return dataRaw;
+  if (data == null) return void 0;
+  try {
+    return JSON.stringify(JSON.parse(data));
+  } catch {
+    return data;
+  }
+}
+function isJsonBody(body) {
+  if (!body) return false;
+  try {
+    JSON.parse(body);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildFetchOptions(options) {
+  const headers = { ...options.headers };
+  if (options.body && !headers["Content-Type"] && isJsonBody(options.body)) {
+    headers["Content-Type"] = "application/json";
+  }
+  const init = {
+    method: options.method,
+    headers
+  };
+  if (options.body && options.method !== "GET" && options.method !== "HEAD") {
+    init.body = options.body;
+  }
+  if (!options.followRedirects) {
+    init.redirect = "manual";
+  }
+  return init;
+}
+function formatResponseBody(body, pretty) {
+  if (!pretty) return body;
+  try {
+    return JSON.stringify(JSON.parse(body), null, 2);
+  } catch {
+    return body;
+  }
+}
+function rewriteUrlToProxy(originalUrl) {
+  const match = originalUrl.match(/^(https?):\/\/([^\/]+)(\/.*)?$/i);
+  if (!match) {
+    throw new Error(`Invalid URL: ${originalUrl}`);
+  }
+  const scheme = match[1];
+  const domain = match[2];
+  const path = match[3] || "/";
+  return `https://proxy.qodalis.com/proxy/${scheme}/${domain}${path}`;
+}
+function buildCurlEquivalent(url, method, headers, body) {
+  const parts = ["curl"];
+  if (method !== "GET") {
+    parts.push(`-X ${method}`);
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    parts.push(`-H '${key}: ${value}'`);
+  }
+  if (body) {
+    parts.push(`-d '${body}'`);
+  }
+  parts.push(`'${url}'`);
+  return parts.join(" ");
+}
+function extractResponseHeaders(response) {
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return headers;
+}
+
+// src/lib/version.ts
+var LIBRARY_VERSION = "2.0.0-beta.10";
+var API_VERSION = 2;
+
+// src/lib/processors/cli-curl-command-processor.ts
+var CliCurlCommandProcessor = class {
+  constructor() {
+    this.command = "curl";
+    this.description = "Make HTTP requests from the terminal. Supports all HTTP methods, custom headers, request bodies, timeouts, and more.";
+    this.author = cliCore.DefaultLibraryAuthor;
+    this.version = LIBRARY_VERSION;
+    this.valueRequired = true;
+    this.metadata = {
+      icon: "\u{1F310}",
+      requiredCoreVersion: ">=2.0.0 <3.0.0",
+      requiredCliVersion: ">=2.0.0 <3.0.0"
+    };
+    this.configurationOptions = [
+      {
+        key: "defaultTimeout",
+        label: "Default Timeout",
+        description: "Default request timeout in milliseconds",
+        type: "number",
+        defaultValue: 3e4,
+        validator: (v) => ({
+          valid: typeof v === "number" && v >= 1e3 && v <= 3e5,
+          message: "Must be between 1000 and 300000 ms"
+        })
+      },
+      {
+        key: "prettyPrint",
+        label: "Pretty-Print JSON",
+        description: "Pretty-print JSON responses by default",
+        type: "boolean",
+        defaultValue: false
+      },
+      {
+        key: "verbose",
+        label: "Verbose Output",
+        description: "Show request/response headers by default",
+        type: "boolean",
+        defaultValue: false
+      }
+    ];
+    this.parameters = [
+      {
+        name: "request",
+        aliases: ["X"],
+        type: "string",
+        description: "HTTP method (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)",
+        required: false
+      },
+      {
+        name: "header",
+        aliases: ["H"],
+        type: "array",
+        description: "Add header, e.g. -H 'Content-Type: application/json' (repeatable)",
+        required: false
+      },
+      {
+        name: "data",
+        aliases: ["d"],
+        type: "string",
+        description: "Request body (auto-detects JSON, sets method to POST if -X not given)",
+        required: false
+      },
+      {
+        name: "data-raw",
+        type: "string",
+        description: "Request body sent as-is without JSON parsing",
+        required: false
+      },
+      {
+        name: "verbose",
+        aliases: ["v"],
+        type: "boolean",
+        description: "Show request/response headers and timing",
+        required: false
+      },
+      {
+        name: "pretty",
+        type: "boolean",
+        description: "Pretty-print JSON response body",
+        required: false
+      },
+      {
+        name: "timeout",
+        type: "number",
+        description: "Request timeout in milliseconds (default: 30000)",
+        required: false,
+        defaultValue: "30000"
+      },
+      {
+        name: "location",
+        aliases: ["L"],
+        type: "boolean",
+        description: "Follow redirects (default: true)",
+        required: false
+      },
+      {
+        name: "proxy",
+        type: "boolean",
+        description: "Route request through proxy.qodalis.com (bypasses CORS)",
+        required: false
+      },
+      {
+        name: "silent",
+        aliases: ["s"],
+        type: "boolean",
+        description: "Only output response body (no status line)",
+        required: false
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    const url = command.value;
+    if (!url) {
+      context.writer.writeError("URL is required. Usage: curl <url> [options]");
+      context.process.exit(1);
+      return;
+    }
+    const args = command.args;
+    const cfgTimeout = cliCore.getPluginConfigValue(context, "curl", "defaultTimeout", 3e4);
+    const cfgPretty = cliCore.getPluginConfigValue(context, "curl", "prettyPrint", false);
+    const cfgVerbose = cliCore.getPluginConfigValue(context, "curl", "verbose", false);
+    const explicitMethod = args["request"] || args["X"];
+    const data = args["data"] || args["d"];
+    const dataRaw = args["data-raw"];
+    const hasBody = data != null || dataRaw != null;
+    const verbose = args["verbose"] != null || args["v"] != null ? !!args["verbose"] || !!args["v"] : cfgVerbose;
+    const pretty = args["pretty"] != null ? !!args["pretty"] : cfgPretty;
+    const silent = !!args["silent"] || !!args["s"];
+    const useProxy = !!args["proxy"];
+    const timeout = parseInt(args["timeout"] || String(cfgTimeout), 10);
+    const followRedirects = args["location"] !== false && args["L"] !== false;
+    let method;
+    try {
+      method = inferMethod(explicitMethod, hasBody);
+    } catch (e) {
+      context.writer.writeError(e.message);
+      context.process.exit(1);
+      return;
+    }
+    const headers = parseHeaders(args["header"] || args["H"]);
+    const body = resolveBody(data, dataRaw);
+    const requestUrl = useProxy ? rewriteUrlToProxy(url) : url;
+    const fetchOptions = buildFetchOptions({
+      method,
+      headers,
+      body,
+      followRedirects
+    });
+    if (verbose) {
+      context.writer.writeln(
+        `> ${context.writer.wrapInColor(`${method} ${url}`, cliCore.CliForegroundColor.Cyan)}`
+      );
+      for (const [key, value] of Object.entries(headers)) {
+        context.writer.writeln(
+          `> ${context.writer.wrapInColor(`${key}: ${value}`, cliCore.CliForegroundColor.Yellow)}`
+        );
+      }
+      if (body) {
+        context.writer.writeln(`> Body: ${body}`);
+      }
+      context.writer.writeln();
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    fetchOptions.signal = controller.signal;
+    const startTime = performance.now();
+    try {
+      const response = await fetch(requestUrl, fetchOptions);
+      const elapsed = Math.round(performance.now() - startTime);
+      const responseText = await response.text();
+      const responseHeaders = extractResponseHeaders(response);
+      const curlResponse = {
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders,
+        body: responseText,
+        timing: elapsed,
+        url: response.url,
+        redirected: response.redirected
+      };
+      if (!silent) {
+        const statusColor = response.ok ? cliCore.CliForegroundColor.Green : cliCore.CliForegroundColor.Red;
+        context.writer.writeln(
+          context.writer.wrapInColor(
+            `HTTP ${response.status} ${response.statusText}`,
+            statusColor
+          )
+        );
+      }
+      if (verbose) {
+        context.writer.writeln();
+        for (const [key, value] of Object.entries(responseHeaders)) {
+          context.writer.writeln(
+            `< ${context.writer.wrapInColor(`${key}: ${value}`, cliCore.CliForegroundColor.Yellow)}`
+          );
+        }
+        context.writer.writeln(
+          `< ${context.writer.wrapInColor(`Time: ${elapsed}ms`, cliCore.CliForegroundColor.Magenta)}`
+        );
+        if (response.redirected) {
+          context.writer.writeln(
+            `< ${context.writer.wrapInColor(`Redirected to: ${response.url}`, cliCore.CliForegroundColor.Cyan)}`
+          );
+        }
+        context.writer.writeln();
+      }
+      const formattedBody = formatResponseBody(responseText, pretty);
+      if (formattedBody) {
+        context.writer.writeln(formattedBody);
+      }
+      if (verbose) {
+        context.writer.writeln();
+        context.writer.writeInfo("Equivalent curl command:");
+        context.writer.writeln(buildCurlEquivalent(url, method, headers, body));
+      }
+      context.process.output(curlResponse);
+    } catch (error) {
+      if (error.name === "AbortError") {
+        context.writer.writeError(`Request timed out after ${timeout}ms`);
+      } else {
+        context.writer.writeError(`Request failed: ${error.message}`);
+      }
+      context.process.exit(1);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  writeDescription(context) {
+    const { writer } = context;
+    writer.writeln(this.description);
+    writer.writeln();
+    writer.writeln(writer.wrapInColor("Usage:", cliCore.CliForegroundColor.Yellow));
+    writer.writeln(`  curl <url> [options]`);
+    writer.writeln();
+    writer.writeln(writer.wrapInColor("Options:", cliCore.CliForegroundColor.Yellow));
+    writer.writeln(`  ${writer.wrapInColor("-X, --request <METHOD>", cliCore.CliForegroundColor.Cyan)}   HTTP method (default: GET, or POST if -d given)`);
+    writer.writeln(`  ${writer.wrapInColor("-H, --header <header>", cliCore.CliForegroundColor.Cyan)}    Add header (repeatable)`);
+    writer.writeln(`  ${writer.wrapInColor("-d, --data <body>", cliCore.CliForegroundColor.Cyan)}        Request body (auto-detects JSON)`);
+    writer.writeln(`  ${writer.wrapInColor("--data-raw <body>", cliCore.CliForegroundColor.Cyan)}        Request body as-is`);
+    writer.writeln(`  ${writer.wrapInColor("-v, --verbose", cliCore.CliForegroundColor.Cyan)}            Show headers and timing`);
+    writer.writeln(`  ${writer.wrapInColor("--pretty", cliCore.CliForegroundColor.Cyan)}                 Pretty-print JSON response`);
+    writer.writeln(`  ${writer.wrapInColor("--timeout <ms>", cliCore.CliForegroundColor.Cyan)}           Timeout in ms (default: 30000)`);
+    writer.writeln(`  ${writer.wrapInColor("-L, --location", cliCore.CliForegroundColor.Cyan)}           Follow redirects (default: true)`);
+    writer.writeln(`  ${writer.wrapInColor("--proxy", cliCore.CliForegroundColor.Cyan)}                  Route through CORS proxy`);
+    writer.writeln(`  ${writer.wrapInColor("-s, --silent", cliCore.CliForegroundColor.Cyan)}             Only output body`);
+    writer.writeln();
+    writer.writeln(writer.wrapInColor("Examples:", cliCore.CliForegroundColor.Yellow));
+    writer.writeln(`  curl https://api.example.com/users`);
+    writer.writeln(`  curl https://api.example.com/users -X POST -d '{"name":"John"}' -H 'Content-Type: application/json'`);
+    writer.writeln(`  curl https://api.example.com/users -v --pretty`);
+    writer.writeln(`  curl https://api.example.com/status -X HEAD`);
+    writer.writeln(`  curl https://api.example.com/data --proxy --timeout 5000`);
+    writer.writeln();
+    writer.writeWarning("The server must allow CORS for this tool to work. Use --proxy to bypass CORS restrictions.");
+  }
+  async initialize(_context) {
+  }
+};
+
+// src/public-api.ts
+var curlModule = {
+  apiVersion: API_VERSION,
+  name: "@qodalis/cli-curl",
+  processors: [new CliCurlCommandProcessor()],
+  translations: {
+    es: { "cli.curl.description": "Realizar solicitudes HTTP desde la terminal" },
+    fr: { "cli.curl.description": "Effectuer des requ\xEAtes HTTP depuis le terminal" },
+    de: { "cli.curl.description": "HTTP-Anfragen vom Terminal ausf\xFChren" },
+    pt: { "cli.curl.description": "Fazer requisi\xE7\xF5es HTTP pelo terminal" },
+    it: { "cli.curl.description": "Eseguire richieste HTTP dal terminale" },
+    ja: { "cli.curl.description": "\u30BF\u30FC\u30DF\u30CA\u30EB\u304B\u3089HTTP\u30EA\u30AF\u30A8\u30B9\u30C8\u3092\u5B9F\u884C" },
+    ko: { "cli.curl.description": "\uD130\uBBF8\uB110\uC5D0\uC11C HTTP \uC694\uCCAD \uC218\uD589" },
+    zh: { "cli.curl.description": "\u4ECE\u7EC8\u7AEF\u53D1\u9001 HTTP \u8BF7\u6C42" },
+    ru: { "cli.curl.description": "\u0412\u044B\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 HTTP-\u0437\u0430\u043F\u0440\u043E\u0441\u043E\u0432 \u0438\u0437 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u0430" },
+    ro: { "cli.curl.description": "Efectueaz\u0103 cereri HTTP din terminal" }
+  }
+};
+
+exports.CliCurlCommandProcessor = CliCurlCommandProcessor;
+exports.buildCurlEquivalent = buildCurlEquivalent;
+exports.buildFetchOptions = buildFetchOptions;
+exports.curlModule = curlModule;
+exports.extractResponseHeaders = extractResponseHeaders;
+exports.formatResponseBody = formatResponseBody;
+exports.inferMethod = inferMethod;
+exports.isJsonBody = isJsonBody;
+exports.parseHeaders = parseHeaders;
+exports.resolveBody = resolveBody;
+exports.rewriteUrlToProxy = rewriteUrlToProxy;
+//# sourceMappingURL=public-api.js.map
+//# sourceMappingURL=public-api.js.map