curlie 1.0.0

package/README.md

@@ -0,0 +1,202 @@
+# nodeCurl
+
+A curl-like CLI tool for Node.js - transfer data from HTTP, HTTPS, FTP servers and local files.
+
+## Installation
+
+```bash
+npm install -g curlie
+```
+
+## Usage
+
+```
+nodecurl [options] <url>
+nodecurl ftp://<host>/<path>
+nodecurl file://<path>
+```
+
+## Options
+
+### HTTP Options
+
+| Flag | Description |
+|------|-------------|
+| `-X, --request <method>` | HTTP method (GET, POST, PUT, DELETE, etc) |
+| `-d, --data <data>` | HTTP POST data |
+| `--json <json>` | JSON data (sets Content-Type: application/json) |
+| `-H, --header <header>` | Add custom header (Header: Value) |
+| `-A, --user-agent <name>` | User-Agent string |
+| `-e, --referer <URL>` | Referer URL |
+| `-b, --cookie <data>` | Cookie string or @filename |
+| `-c, --cookie-jar <file>` | Save cookies to file |
+| `-i, --include` | Include response headers in output |
+| `-v, --verbose` | Show request/response details |
+| `-k, --insecure` | Allow insecure SSL connections |
+| `-L, --location` | Follow redirects |
+| `--max-redirs <num>` | Max redirects to follow |
+| `--retry <num>` | Retry on transient errors |
+| `--limit-rate <speed>` | Limit transfer speed |
+
+### Output Options
+
+| Flag | Description |
+|------|-------------|
+| `-o, --output <file>` | Write to file |
+| `-O, --remote-name` | Write using remote filename |
+| `--output-dir <dir>` | Output directory |
+| `-I, --head` | Fetch headers only |
+| `-R, --remote-time` | Preserve remote timestamp |
+| `--no-clobber` | Don't overwrite files |
+| `--create-dirs` | Create directories |
+
+### Connection Options
+
+| Flag | Description |
+|------|-------------|
+| `--max-time <seconds>` | Total timeout |
+| `--connect-timeout <seconds>` | Connection timeout |
+| `--limit-rate <speed>` | Speed limit (e.g. 1M, 100K) |
+| `-Z, --parallel <urls>` | Parallel downloads |
+| `--parallel-max <num>` | Max parallel connections |
+
+### DNS Options
+
+| Flag | Description |
+|------|-------------|
+| `--resolve <host:port:addr>` | Custom address for host:port |
+| `--dns-servers <addrs>` | DNS servers (comma-separated) |
+| `--doh-url <url>` | DNS-over-HTTPS URL |
+| `-4, --ipv4` | IPv4 only |
+| `-6, --ipv6` | IPv6 only |
+
+### FTP Options
+
+| Flag | Description |
+|------|-------------|
+| `-u, --user <user:password>` | Authentication |
+| `-l, --list-only` | List directory contents |
+| `-I, --head` | Get file metadata only |
+| `-o, --output <file>` | Download to local file |
+| `-T, --upload <file>` | Upload local file |
+| `-a, --append` | Append to remote file |
+| `-Q, --quote <command>` | Command before transfer |
+| `-v, --verbose` | Show protocol details |
+
+### Authentication
+
+| Flag | Description |
+|------|-------------|
+| `-u, --user <user:password>` | Server user and password |
+| `-k, --insecure` | Allow insecure server connections |
+
+## Examples
+
+### Basic Requests
+
+```bash
+# Simple GET request
+nodecurl https://example.com
+
+# With SSL skip (insecure)
+nodecurl -k https://example.com
+
+# POST with data
+nodecurl -X POST -d "name=test&value=123" https://api.example.com
+
+# POST with JSON
+nodecurl --json '{"name":"test"}' https://api.example.com
+```
+
+### File Downloads
+
+```bash
+# Save to specific file
+nodecurl -o page.html https://example.com/page
+
+# Save with remote filename
+nodecurl -O https://example.com/file.txt
+
+# Save to directory
+nodecurl --output-dir ./downloads https://example.com/file
+```
+
+### Headers & Cookies
+
+```bash
+# Custom headers
+nodecurl -H "Authorization: Bearer token" https://api.example.com
+
+# Custom User-Agent
+nodecurl -A "MyBot/1.0" https://example.com
+
+# Save cookies
+nodecurl -c cookies.txt https://example.com
+
+# Send cookies
+nodecurl -b cookies.txt https://example.com
+```
+
+### Redirects
+
+```bash
+# Follow redirects (default)
+nodecurl -L https://example.com/redirect
+
+# Limit redirects
+nodecurl -L --max-redirs 3 https://example.com/redirect
+```
+
+### FTP
+
+```bash
+# List directory
+nodecurl ftp://ftp.example.com/
+
+# Download file
+nodecurl -o local.txt ftp://ftp.example.com/file.txt
+
+# Upload file
+nodecurl -T local.txt ftp://ftp.example.com/upload/
+```
+
+### Advanced
+
+```bash
+# Custom DNS resolve
+nodecurl --resolve example.com:443:127.0.0.1 https://example.com
+
+# DNS-over-HTTPS
+nodecurl --doh-url https://dns.google/resolve https://example.com
+
+# Speed limit
+nodecurl --limit-rate 1M https://example.com/large-file
+
+# Parallel downloads
+nodecurl -Z url1 url2 url3
+
+# Verbose output
+nodecurl -v https://example.com
+```
+
+## Help
+
+```bash
+nodecurl -h           # Show all options
+nodecurl http -h      # HTTP options only
+nodecurl ftp -h      # FTP options only
+nodecurl dns -h      # DNS options only
+```
+
+## Exit Codes
+
+- `0` - Success
+- `1` - General error
+- `2` - Parse error
+- `3` - Network error
+- `4` - SSL error
+- `28` - Operation timeout
+
+## License
+
+MIT

package/bin/index.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { parseFlags } from "../lib/flags.js";
+import { ftpList } from "../lib/ftpHandler.js";
+import { expandLocalVars, isFileURL, isFtp, showHelp } from "../lib/utils.js";
+import { readLocalFile, createFile, readHeaders } from "../lib/fileHandler.js";
+import { parallelRequests, request } from "../lib/httpHandler.js";
+
+const args = process.argv.slice(2);
+const flags = parseFlags(args);
+const nonFlagArgs = args.filter((arg) => !arg.startsWith("-"));
+const module = nonFlagArgs[0];
+
+let url = args.find(
+  (arg) =>
+    arg.startsWith("http://") ||
+    arg.startsWith("https://") ||
+    arg.startsWith("file://") ||
+    arg.startsWith("ftp://"),
+);
+
+let urls = args.filter((item) => !item.startsWith("--")) || [];
+
+url = expandLocalVars(url);
+
+if (flags.user === undefined) flags.user = "anonymous:anonymous";
+
+const main = async () => {
+  if (!url && !flags.help && !flags.parallel) {
+    console.log("Error: Usage: ./index.js [options] <url>");
+    process.exitCode = 1;
+    return;
+  }
+
+  if (flags.help) {
+    showHelp(module);
+    return;
+  }
+
+  if (isFtp(url)) {
+    await ftpList(url, flags);
+    return;
+  }
+
+  if (isFileURL(url)) {
+    if (flags.upload) {
+      createFile(url, flags);
+    } else if (flags.head) {
+      await readHeaders(url, flags);
+    } else {
+      readLocalFile(url, flags);
+    }
+    return;
+  }
+
+  if (flags.parallel) {
+    await parallelRequests(urls, flags);
+  } else {
+    let method = flags.method || (flags.upload ? "PUT" : "GET");
+    await request(url, method, flags);
+  }
+};
+
+(async () => {
+  try {
+    await main();
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+})();

package/bin/localfile.txt

@@ -0,0 +1 @@
+hello ftp

package/eslint.config.js

@@ -0,0 +1,7 @@
+import js from "@eslint/js";
+import globals from "globals";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  { files: ["**/*.{js,mjs,cjs}"], plugins: { js }, extends: ["js/recommended"], languageOptions: { globals: globals.browser } },
+]);

package/lib/dnsHandler.js

@@ -0,0 +1,141 @@
+import dns from "dns";
+import https from "https";
+import { URL } from "url";
+
+export function createDnsLookup(flags = {}) {
+  const resolveMap = parseResolveFlags(flags.resolve);
+
+  const customServers = flags.dnsServers || null;
+  const useIPv4 = !!flags.ipv4;
+  const useIPv6 = !!flags.ipv6;
+
+  if (customServers) {
+    try {
+      const servers = customServers.flatMap((s) => s.split(","));
+      dns.setServers(servers);
+    } catch (err) {
+      console.warn("[dns] failed to set DNS servers:", err.message);
+    }
+  }
+
+  if (flags.dohUrl) {
+    return function lookup(hostname, opts = {}, cb) {
+      dohLookup(flags.dohUrl, hostname, opts, useIPv4, useIPv6, cb);
+    };
+  }
+
+  if (resolveMap.size > 0) {
+    return function lookup(hostname, opts = {}, cb) {
+      const port = opts.port;
+      const key = port ? `${hostname}:${port}` : null;
+
+      if (key && resolveMap.has(key)) {
+        const ip = resolveMap.get(key);
+        const family = ip.includes(":") ? 6 : 4;
+
+        if (opts.all) {
+          return cb(null, [{ address: ip, family }]);
+        }
+
+        return cb(null, ip, family);
+      }
+
+      defaultLookup(hostname, opts, useIPv4, useIPv6, cb);
+    };
+  }
+
+  return function lookup(hostname, opts = {}, cb) {
+    defaultLookup(hostname, opts, useIPv4, useIPv6, cb);
+  };
+}
+
+function parseResolveFlags(list) {
+  const map = new Map();
+  if (!list) return map;
+
+  if (typeof list === "string") list = [list];
+
+  for (const entry of list) {
+    const [host, port, addr] = entry.split(":");
+    if (host && port && addr) {
+      map.set(`${host}:${port}`, addr);
+    }
+  }
+  return map;
+}
+
+
+function defaultLookup(hostname, opts, force4, force6, cb) {
+  const family = force4 ? 4 : force6 ? 6 : undefined;
+
+  dns.lookup(hostname, { ...opts, family }, (err, res, fam) => {
+    if (err) {
+      console.error("[dns] lookup error:", err.message);
+      return cb(err);
+    }
+
+    if (Array.isArray(res)) {
+      if (opts.all) {
+        return cb(null, res);
+      }
+
+      const first = res[0];
+      return cb(null, first.address, first.family);
+    }
+
+    cb(null, res, fam);
+  });
+}
+
+function dohLookup(dohUrl, hostname, opts, force4, force6, cb) {
+  try {
+    const wantIPv6 = force6 && !force4;
+    const rrType = wantIPv6 ? 28 : 1;
+
+    const url = new URL(dohUrl);
+    url.searchParams.set("name", hostname);
+    url.searchParams.set("type", wantIPv6 ? "AAAA" : "A");
+
+    https
+      .get(url, { headers: { accept: "application/dns-json" } }, (res) => {
+        let body = "";
+
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(body);
+
+            const answer = json.Answer?.find(
+              (a) =>
+                a.type === rrType &&
+                typeof a.data === "string" &&
+                isValidIP(a.data),
+            );
+
+            if (!answer) {
+              return cb(new Error("[dns:doh] no usable DNS answer"));
+            }
+
+            const address = answer.data;
+            const family = wantIPv6 ? 6 : 4;
+
+            if (opts.all) {
+              return cb(null, [{ address, family }]);
+            }
+
+            cb(null, address, family);
+          } catch (err) {
+            cb(err);
+          }
+        });
+      })
+      .on("error", cb);
+  } catch (err) {
+    cb(err);
+  }
+}
+
+
+function isValidIP(ip) {
+  return typeof ip === "string" && (ip.includes(".") || ip.includes(":"));
+}

package/lib/fileHandler.js

@@ -0,0 +1,77 @@
+import fs from "fs";
+import { writeOutput, expandLocalVars } from "./utils.js";
+import { stat as statAsync } from "fs/promises";
+
+export function readLocalFile(url, flags) {
+  const filePath = url.replace("file://", "");
+
+  if (!fs.existsSync(filePath)) {
+    console.error("File does not exist:", filePath);
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(filePath);
+
+  if (flags.head) {
+    writeOutput(
+      `Status: 200 OK\nContent-Length: ${stat.size}\nContent-Type: text/plain\n`,
+      flags,
+    );
+    return;
+  }
+
+  if (flags["list-only"]) {
+    if (!stat.isDirectory()) {
+      console.error("-l works only on directories");
+      process.exit(1);
+    }
+    const items = fs.readdirSync(filePath).join("\n");
+    writeOutput(items, flags);
+    return;
+  }
+
+  let content = fs.readFileSync(filePath);
+  writeOutput(content, flags);
+}
+
+export function createFile(url, flags) {
+  const targetPath = url.replace("file://", "");
+  let data;
+
+  if (flags.upload === "-") {
+    data = fs.readFileSync(0);
+  } else {
+    const uploadPath = expandLocalVars(flags.upload);
+    if (!fs.existsSync(uploadPath)) {
+      console.error("Upload file does not exist:", uploadPath);
+      process.exit(1);
+    }
+    data = fs.readFileSync(uploadPath);
+  }
+
+  const mode = flags["create-file-mode"]
+    ? parseInt(flags["create-file-mode"], 8)
+    : 0o644;
+
+  fs.writeFileSync(targetPath, data, { mode });
+  fs.chmodSync(targetPath, mode);
+  console.log(`Created file: ${targetPath} (${mode.toString(8)})`);
+}
+
+export async function readHeaders(url, flags) {
+  const filePath = url.replace("file://", "");
+  try {
+    const stats = await statAsync(filePath);        
+    
+    const headers =
+      `Status: 200 OK\n` +        
+      `Content-Length: ${stats.size}\n` +           
+      `Last-Modified: ${stats.mtime.toUTCString()}\n`;   
+
+    // writeOutput(headers, flags);  
+    console.log(headers)    
+  } catch (err) {  
+    console.error("File not found:", filePath);
+    process.exit(1);  
+  }
+}

package/lib/flags.js

@@ -0,0 +1,141 @@
+const FLAG_DEFS = {
+  "-o": { key: "output", type: "string" },
+  "-l": { key: "listOnly", type: "boolean" },
+  "--list-only": { key: "listOnly", type: "boolean" },
+  "-4": { key: "ipv4", type: "boolean" },
+  "-6": { key: "ipv6", type: "boolean" },
+  "-h": { key: "help", type: "boolean" },
+
+  // output module
+  "-O": { key: "remoteName", type: "boolean" },
+  "-I": { key: "head", type: "boolean" },
+  "-R": { key: "preserveTimeStamp", type: "boolean" },
+  "--create-dirs": { key: "createDirs", type: "boolean" },
+  "--create-file-mode": { key: "create-file-mode", type: "boolean" },
+  "--no-clobber": { key: "noClobber", type: "boolean" },
+  "-N": { key: "noBuffer", type: "boolean" },
+  "--output-dir": { key: "outputDir", type: "string" },
+
+  // ftp module
+  "-Q": { key: "quote", type: "array" },
+  "-a": { key: "append", type: "boolean" },
+  "--append": { key: "append", type: "boolean" },
+
+  "--retry": { key: "retry", type: "number" },
+
+  // connection module
+  "--limit-rate": { key: "rateLimit", type: "number" },
+  "--max-time": { key: "maxTimeout", type: "number" },
+  "--connect-timeout": { key: "timeout", type: "number" },
+  "-Y": { key: "speedLimit", type: "number" },
+  "--speed-limit": { key: "speedLimit", type: "number" },
+  "-y": { key: "speedTime", type: "number" },
+  "--speed-time": { key: "speedTime", type: "number" },
+  "-Z": { key: "parallel", type: "array" },
+  "--parallel": { key: "parallel", type: "array" },
+  "--parallel-max": { key: "parallelMax", type: "number" },
+  "--parallel-immediate": { key: "parallelImmediate", type: "boolean" },
+  "--max-filesize": { key: "maxFilesize", type: "number" },
+  // ---------------- //
+
+  // DNS / resolving
+  "--dns-servers": { key: "dnsServers", type: "array" },
+  "--doh-url": { key: "dohUrl", type: "string" },
+  "--doh-insecure": { key: "dohInsecure", type: "boolean" },
+  "--doh-cert-status": { key: "dohCertStatus", type: "boolean" },
+
+  "--connect-to": { key: "connectTo", type: "array" },
+  "--dns-interface": { key: "dnsInterface", type: "string" },
+  "--dns-ipv4-addr": { key: "dnsIpv4Addr", type: "string" },
+  "--dns-ipv6-addr": { key: "dnsIpv6Addr", type: "string" },
+  // ----------------- //
+
+  "-u": { key: "user", type: "string" },
+  "-T": { key: "upload", type: "string" },
+  "--upload-file": { key: "upload", type: "string" },
+
+  "-X": { key: "method", type: "string" },
+  "-d": { key: "data", type: "string" },
+  "--data": { key: "data", type: "string" },
+  "--json": { key: "json", type: "string" },
+  "-H": { key: "headers", type: "array" },
+  "--header": { key: "headers", type: "array" },
+  "--POST": { key: "POST", type: "boolean" },
+  "--PUT": { key: "PUT", type: "boolean" },
+  "--DELETE": { key: "DELETE", type: "boolean" },
+  "--GET": { key: "GET", type: "boolean" },
+  "--resolve": { key: "resolve", type: "array" },
+
+  // SSL/TLS
+  "-k": { key: "insecure", type: "boolean" },
+  "--insecure": { key: "insecure", type: "boolean" },
+
+  // Redirects
+  "-L": { key: "location", type: "boolean" },
+  "--location": { key: "location", type: "boolean" },
+  "--max-redirs": { key: "maxRedirs", type: "number" },
+
+  // Headers
+  "-A": { key: "userAgent", type: "string" },
+  "--user-agent": { key: "userAgent", type: "string" },
+  "-e": { key: "referer", type: "string" },
+  "--referer": { key: "referer", type: "string" },
+
+  // Output
+  "-i": { key: "include", type: "boolean" },
+  "--include": { key: "include", type: "boolean" },
+  "-v": { key: "verbose", type: "boolean" },
+  "--verbose": { key: "verbose", type: "boolean" },
+
+  // Cookies
+  "-c": { key: "cookieJar", type: "string" },
+  "--cookie-jar": { key: "cookieJar", type: "string" },
+  "-b": { key: "cookie", type: "string" },
+  "--cookie": { key: "cookie", type: "string" },
+};
+
+export function parseFlags(args) {
+  const flags = {};
+
+  for (let i = 0; i < args.length; i++) {
+    let arg = args[i];
+    let value;
+
+    // Handle --key=value
+    if (arg.includes("=")) {
+      const parts = arg.split("=");
+      arg = parts[0];
+      value = parts.slice(1).join("=");
+    }
+
+    const def = FLAG_DEFS[arg];
+    if (!def) continue;
+
+    switch (def.type) {
+      case "boolean":
+        flags[def.key] = true;
+        break;
+
+      case "string":
+      case "number":
+        if (value === undefined) value = args[++i];
+        flags[def.key] = def.type === "number" ? Number(value) : value;
+        break;
+
+      case "array":
+        if (value === undefined) value = args[++i];
+        flags[def.key] ??= [];
+        if (def.key === "headers") {
+          // Parse "Key: Value" to object
+          const [k, ...v] = value.split(":");
+          flags.headers ??= {};
+          flags.headers[k.trim()] = v.join(":").trim();
+        } else {
+          flags[def.key].push(value);
+        }
+        break;
+    }
+  }
+
+  return flags;
+}