curl-wrap 2.0.1 → 2.1.1

package/README.md

@@ -45,6 +45,9 @@ curl.headers({
     'User-Agent': 'curl-wrap/1.0',
     'Accept': 'application/json'
 });
+
+// clear all headers
+curl.clearHeaders();
 ```
 
 ### Setting Cookies
@@ -98,6 +101,9 @@ curl.impersonate('firefox');
 curl.impersonate('safari');
 curl.impersonate('safariMobile');
 curl.impersonate('edge');
+
+// Or create a new instance with impersonation
+const chromeCurl = Curl.impersonate('chrome');
 ```
 
 ### Setting Request Method
@@ -165,6 +171,66 @@ const response = await curl;
 console.log(response.stderr);
 ```
 
+### Buffer Response
+
+```js
+curl.asBuffer();
+const response = await curl;
+console.log(response.body); // Buffer object instead of string
+```
+
+### Export as Curl Command
+
+```js
+const curl = Curl.url('https://api.example.com')
+    .post()
+    .header('Content-Type', 'application/json')
+    .body({key: 'value'});
+
+const curlCommand = await curl.exportAsCurl();
+console.log(curlCommand);
+// Output:
+// curl 'https://api.example.com' \
+//   --request POST \
+//   --header 'content-type: application/json' \
+//   --data-raw '{"key":"value"}'
+```
+
+### Import from Curl Command
+
+```js
+const curlCommand = `curl 'https://api.example.com' \
+  --request POST \
+  --header 'Content-Type: application/json' \
+  --header 'Authorization: Bearer token123' \
+  --cookie 'session=abc123; user=john' \
+  --data-raw '{"name":"John","age":30}'`;
+
+const curl = Curl.fromCurl(curlCommand);
+const response = await curl;
+```
+
+### Cloning Requests
+
+```js
+const baseCurl = Curl.url('https://api.example.com')
+    .header('Authorization', 'Bearer token123')
+    .header('Content-Type', 'application/json');
+
+// Clone and modify for different endpoints
+const getUserCurl = baseCurl.clone()
+    .url('https://api.example.com/user')
+    .get();
+const createUserCurl = baseCurl.clone()
+    .url('https://api.example.com/user')
+    .post()
+    .body({name: 'John'});
+
+// Both requests share the same headers but have different URLs and methods
+const userResponse = await getUserCurl;
+const createResponse = await createUserCurl;
+```
+
 ### Method Chaining
 
 ```js

package/index.d.ts

@@ -3,6 +3,7 @@ import { CookieJar } from "tough-cookie";
 interface CurlOptions {
   method?: string; // HTTP method (e.g., GET, POST)
   headers?: Record<string, string>; // Request headers
+  cookies?: Record<string, string>; // Request cookies
   body?: string | object | null; // Request body
   timeout?: number; // Timeout in milliseconds
   [key: string]: any; // Allow additional options
@@ -10,7 +11,7 @@ interface CurlOptions {
 
 interface CurlResponse {
   url: string;
-  body: string; // Response body as a string
+  body: string | Buffer; // Response body as a string or Buffer
   headers: Record<string, string>; // Response headers
   statusCode: number; // HTTP status code
   status: number; // alias for .statusCode
@@ -50,6 +51,8 @@ export class Curl {
   static getGlobalCookieJar(): CookieJar;
 
   static hasCurlImpersonate(): boolean;
+  static impersonate(browser?: BrowserType): Curl;
+  static fromCurl(curlCommand: string): Curl;
 
   cliCommand(command: string): Curl;
   cliOptions(options: string | string[]): Curl;
@@ -61,6 +64,7 @@ export class Curl {
 
   header(headerName: string | object, headerValue?: string): Curl;
   headers(headers: object): Curl;
+  clearHeaders(): Curl;
 
   json(body?: object): Curl;
   body(body: any, contentType?: string): Curl;
@@ -78,10 +82,11 @@ export class Curl {
     cookieName: string | boolean | object,
     cookieValue?: string
   ): Curl;
-  cookies(cookies: object | boolean): Curl;
+  cookies(cookies: object | boolean | string): Curl;
 
   globalCookies(options?: boolean | object): Curl;
   cookieJar(cookieJar: CookieJar, options?: { readOnly?: boolean }): Curl;
+  getCookieJar(): CookieJar | undefined;
   cookieFile(fileName: string, options?: object): Curl;
 
   timeout(timeout: number): Curl;
@@ -113,6 +118,12 @@ export class Curl {
 
   verbose(isVerbose?: boolean): Curl;
 
+  asBuffer(returnAsBuffer?: boolean): Curl;
+
+  clone(): Curl;
+
+  exportAsCurl(): Promise<string>;
+
   fetch(): Promise<CurlResponse>;
 
   then(
@@ -130,4 +141,9 @@ export class Curl {
   private options: any;
   private _fields: Record<string, any>;
   private _query: Record<string, any>;
+  private _cookies: Record<string, any>;
+  private _cookieJar?: CookieJar;
+  private _readCookieJar?: CookieJar;
+  private _cookieFileFn?: () => Promise<void>;
+  private _cookieFileFnRes?: () => Promise<void>;
 }

package/index.js

@@ -42,10 +42,59 @@ function makeProxyUrl(proxy, options) {
 	return uri.toString();
 }
 
+/**
+ * Parse curl command string into arguments array
+ * 
+ * @param {string} command
+ * @return {string[]}
+ */
+function parseCommand(command) {
+	// Clean up the command - remove line breaks and extra spaces
+	command = command.replace(/\\\s*\n/g, ' ').replace(/\s+/g, ' ').trim();
+
+	const args = [];
+	let current = '';
+	let inQuotes = false;
+	let quoteChar = '';
+	
+	for (let i = 0; i < command.length; i++) {
+		const char = command[i];
+		const nextChar = command[i + 1];
+		
+		if ((char === '"' || char === "'") && !inQuotes) {
+			inQuotes = true;
+			quoteChar = char;
+		}
+		else if (char === quoteChar && inQuotes) {
+			inQuotes = false;
+			quoteChar = '';
+		}
+		else if (char === ' ' && !inQuotes) {
+			if (current.trim()) {
+				args.push(current.trim());
+				current = '';
+			}
+		}
+		else if (char === '\\' && nextChar === quoteChar && inQuotes) {
+			current += nextChar;
+			i++; // Skip next character
+		}
+		else {
+			current += char;
+		}
+	}
+	
+	if (current.trim()) {
+		args.push(current.trim());
+	}
+	
+	return args;
+}
+
 class CurlResponse {
-	constructor() {
+	constructor({body = ''} = {}) {
 		this.url = '';
-		this.body = '';
+		this.body = body;
 		this.headers = {};
 		this.statusCode = 0;
 		this.ip = '';
@@ -81,6 +130,31 @@ class CurlResponse {
 	}
 }
 
+/**
+ * Parse cookies string into object
+ * 
+ * @param {string} cookieStr
+ * @return {object}
+ */
+function parseCookies(cookieStr) {
+	const cookies = {};
+	if (!cookieStr) return cookies;
+	const parts = cookieStr.split(';');
+	
+	for (const part of parts) {
+		const equalIndex = part.indexOf('=');
+		if (equalIndex !== -1) {
+			const key = part.slice(0, equalIndex).trim();
+			const value = part.slice(equalIndex + 1).trim();
+			if (key && value) {
+				cookies[key] = value;
+			}
+		}
+	}
+	
+	return cookies;
+}
+
 class Curl {
 	/**
 	 * Creates a new Curl object.
@@ -291,10 +365,14 @@ class Curl {
 		return this;
 	}
 
+	/**
+	 * @typedef {"chrome"|"chromeMobile"|"edge"|"safari"|"safariMobile"|"firefox"} BrowserType
+	 */
+
 	/**
 	 * impersonate a browser
 	 *
-	 * @param {string} browser browser to impersonate (chrome / chromeMobile / edge / safari / safariMobile / firefox)
+	 * @param {BrowserType} browser browser to impersonate
 	 * @return {Curl} self
 	 */
 	impersonate(browser = 'chrome') {
@@ -566,6 +644,19 @@ class Curl {
 		return this;
 	}
 
+	/**
+	 * @static
+	 * impersonate a browser
+	 *
+	 * @param {BrowserType} browser browser to impersonate
+	 * @return {Curl} self
+	 */
+	static impersonate(browser = 'chrome') {
+		const curl = new this();
+		curl.impersonate(browser);
+		return curl;
+	}
+
 	/**
 	 * Set or unset the followRedirect option for the connection.
 	 *
@@ -620,6 +711,16 @@ class Curl {
 		return this;
 	}
 
+	/**
+	 * Clear all headers
+	 * 
+	 * @return {Curl} self
+	 */
+	clearHeaders() {
+		this.options.headers = {};
+		return this;
+	}
+
 	/**
 	 * Set the content type as json
 	 * Optionally also set the body of the request.
@@ -739,19 +840,19 @@ class Curl {
 	 */
 	cookie(cookieName, cookieValue) {
 		if (cookieValue === undefined) {
-			this.globalCookies(cookieName);
+			this.cookies(cookieName);
 		}
 		else if (typeof cookieName === 'string') {
-			if (cookieValue === null || cookieValue === false) {
+			if (typeof cookieValue === 'string') {
+				this._cookies[cookieName] = cookieValue;
+			}
+			else if (cookieValue === null || cookieValue === false) {
 				delete this._cookies[cookieName];
 			}
 			else {
-				this._cookies[cookieName] = cookieValue;
+				this._cookies[cookieName] = JSON.stringify(cookieValue);
 			}
 		}
-		else if (cookieName && typeof cookieName === 'object') {
-			Object.assign(this._cookies, cookieName);
-		}
 
 		return this;
 	}
@@ -760,7 +861,7 @@ class Curl {
 	 * Sets multiple cookies.
 	 * Can be used to enable global cookies, if cookies is set to true.
 	 *
-	 * @param {object|boolean} cookies object representing the cookies
+	 * @param {object|boolean|string} cookies object representing the cookies
 	 * and their values as key:value pairs.
 	 * @return {Curl} self
 	 */
@@ -771,6 +872,10 @@ class Curl {
 		else if (cookies && typeof cookies === 'object') {
 			Object.assign(this._cookies, cookies);
 		}
+		else if (typeof cookies === 'string') {
+			const cookies = parseCookies(cookieName);
+			Object.assign(this._cookies, cookies);
+		}
 
 		return this;
 	}
@@ -783,8 +888,8 @@ class Curl {
 	 */
 	globalCookies(options = true) {
 		if (options === false || options === null) {
-			delete this.options.cookieJar;
-			delete this.options.readCookieJar;
+			delete this._cookieJar;
+			delete this._readCookieJar;
 			return this;
 		}
 
@@ -804,15 +909,24 @@ class Curl {
 		delete this._cookieFileFnRes;
 
 		if (options.readOnly) {
-			this.options.readCookieJar = cookieJar;
+			this._readCookieJar = cookieJar;
 		}
 		else {
-			this.options.cookieJar = cookieJar;
+			this._cookieJar = cookieJar;
 		}
 
 		return this;
 	}
 
+	/**
+	 * Get the current cookie jar
+	 *
+	 * @return {CookieJar|undefined} the current cookie jar
+	 */
+	getCookieJar() {
+		return this._cookieJar || this._readCookieJar;
+	}
+
 	/**
 	 * Set the value of cookie jar based on a file (cookie store).
 	 *
@@ -822,10 +936,10 @@ class Curl {
 	cookieFile(fileName, options = {}) {
 		const setCookieJar = (cookieJar) => {
 			if (options.readOnly) {
-				this.options.readCookieJar = cookieJar;
+				this._readCookieJar = cookieJar;
 			}
 			else {
-				this.options.cookieJar = cookieJar;
+				this._cookieJar = cookieJar;
 			}
 		};
 
@@ -843,7 +957,7 @@ class Curl {
 
 		if (!options.readOnly) {
 			this._cookieFileFnRes = async () => {
-				const cookieJar = this.options.cookieJar;
+				const cookieJar = this._cookieJar;
 				if (!cookieJar) return;
 				try {
 					const contents = JSON.stringify(cookieJar.toJSON());
@@ -1088,6 +1202,205 @@ class Curl {
 		return this;
 	}
 
+	/**
+	 * Set if the body is to be returned as a buffer
+	 *
+	 * @param {boolean} [returnAsBuffer=true]
+	 * @return {Curl} self
+	 */
+	asBuffer(returnAsBuffer = true) {
+		this.options.asBuffer = returnAsBuffer;
+		return this;
+	}
+
+	/**
+	 * Create a clone of this Curl instance with the same options
+	 *
+	 * @return {Curl} new Curl instance with cloned options
+	 */
+	clone() {
+		const cloned = new this.constructor();
+		
+		// Deep clone the options object (only serializable properties)
+		cloned.options = JSON.parse(JSON.stringify(this.options));
+		
+		// Copy non-serializable properties
+		if (this._cookieJar) {
+			cloned._cookieJar = this._cookieJar;
+		}
+		if (this._readCookieJar) {
+			cloned._readCookieJar = this._readCookieJar;
+		}
+		if (this._cookieFileFn) {
+			cloned._cookieFileFn = this._cookieFileFn;
+		}
+		if (this._cookieFileFnRes) {
+			cloned._cookieFileFnRes = this._cookieFileFnRes;
+		}
+		
+		return cloned;
+	}
+
+	/**
+	 * Export the current request as a curl command string
+	 *
+	 * @return {Promise<string>} curl command as a string
+	 */
+	async exportAsCurl() {
+		const cmd = this.options.cliCommand || 'curl';
+		const args = await this.getCurlArgs();
+		// Filter out internal options that shouldn't appear in exported commands
+		const skipOptions = ['--silent', '--no-keepalive', '--keepalive', '--write-out', '--insecure', '--location'];
+		const escape = arg => `'${arg.replace(/'/g, "'\"'\"'")}'`;
+		
+		const url = args[0];
+		const lines = [`${cmd} ${escape(url)}`];
+		for (let i = 1; i < args.length; i++) {
+			const arg = String(args[i]);
+			const nextArg = String(args[i + 1] ?? '');
+			const isNextArgValue = !nextArg.startsWith('--');
+			if (isNextArgValue) {
+				i++;
+			}
+			// Skip internal options and their values
+			if (skipOptions.includes(arg)) continue;
+			if (isNextArgValue) {
+				const escapedNextArg = /[\s"'`&:;,><|(){}~^%#@!/=+\$\?\*\[\]]/.test(nextArg) ? escape(nextArg) : nextArg;
+				lines.push(`${arg} ${escapedNextArg}`);
+			}
+			else {
+				lines.push(arg);
+			}
+		}
+		
+		return lines.join(' \\\n  ');
+	}
+
+	/**
+	 * @static
+	 * Create a new Curl instance from a curl command string
+	 *
+	 * @param {string} curlCommand curl command string to parse
+	 * @return {Curl} new Curl instance
+	 */
+	static fromCurl(curlCommand) {
+		const curl = new this();
+		curl.options.headers = {};
+		
+		// Parse the command into arguments
+		const args = parseCommand(curlCommand);
+		
+		let method;
+		let body;
+		
+		// Process arguments
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			const nextArg = args[i + 1];
+			const isNextArgValue = nextArg && !nextArg.startsWith('-');
+			
+			if (i === 0 && !arg.startsWith('curl')) {
+				// First argument should be the URL if no 'curl' command prefix
+				curl.url(arg);
+			}
+			else if (i === 1 && args[0].startsWith('curl')) {
+				// Second argument is URL when first is 'curl'
+				curl.url(arg);
+			}
+			else if (arg === '--request' || arg === '-X') {
+				if (!isNextArgValue) continue;
+				method = nextArg;
+				i++;
+			}
+			else if (arg === '--header' || arg === '-H') {
+				if (!isNextArgValue) continue;
+				const colonIndex = nextArg.indexOf(':');
+				if (colonIndex !== -1) {
+					const headerName = nextArg.slice(0, colonIndex).trim();
+					const headerValue = nextArg.slice(colonIndex + 1).trim();
+					curl.header(headerName, headerValue);
+				}
+				i++;
+			}
+			else if (arg === '--data' || arg === '--data-raw' || arg === '-d') {
+				if (!isNextArgValue) continue;
+				body = nextArg;
+				i++;
+			}
+			else if (arg === '--cookie' || arg === '-b') {
+				if (!isNextArgValue) continue;
+				curl.header('cookie', nextArg);
+				i++;
+			}
+			else if (arg === '--user-agent' || arg === '-A') {
+				if (!isNextArgValue) continue;
+				curl.userAgent(nextArg);
+				i++;
+			}
+			else if (arg === '--referer' || arg === '-e') {
+				if (!isNextArgValue) continue;
+				curl.referer(nextArg);
+				i++;
+			}
+			else if (arg === '--max-time' || arg === '-m') {
+				if (!isNextArgValue) continue;
+				const timeout = Number(nextArg);
+				if (timeout > 0) curl.timeout(timeout);
+				i++;
+			}
+			else if (arg === '--proxy' || arg === '-x') {
+				if (!isNextArgValue) continue;
+				curl.proxy(nextArg);
+				i++;
+			}
+			else if (arg === '--compressed') {
+				curl.compress(true);
+			}
+			else if (arg === '--location' || arg === '-L') {
+				curl.followRedirect(true);
+			}
+			else if (arg === '--max-redirs') {
+				if (!isNextArgValue) continue;
+				const maxRedir = Math.floor(Number(nextArg));
+				if (maxRedir > 0) curl.maxRedirects(maxRedir);
+				i++;
+			}
+			else if (arg === '--verbose' || arg === '-v') {
+				curl.verbose(true);
+			}
+			else if (arg.startsWith('--') || arg.startsWith('-')) {
+				// Ignore internal options that shouldn't be imported
+				const ignoreOptions = ['--silent', '--no-keepalive', '--keepalive', '--write-out', '--insecure'];
+				if (ignoreOptions.includes(arg)) {
+					// If the ignored option has a value, ignore it too
+					if (isNextArgValue) {
+						i++;
+					}
+				}
+				else {
+					// Handle unknown curl options by adding them as cliOptions
+					if (isNextArgValue) {
+						curl.cliOptions([arg, nextArg]);
+						i++; // Skip next argument
+					}
+					else {
+						curl.cliOptions(arg);
+					}
+				}
+			}
+		}
+
+		if (body) {
+			curl.body(body);
+			method = method || 'POST';
+		}
+		if (method) {
+			curl.method(method);
+		}
+		
+		return curl;
+	}
+
 	/**
 	 * Add the options 'fields' to the options body, form or qs
 	 * on the basis of the request method.
@@ -1167,7 +1480,7 @@ class Curl {
 			await this._cookieFileFn();
 		}
 
-		const cookieJar = options.readCookieJar || options.cookieJar;
+		const cookieJar = this._readCookieJar || this._cookieJar;
 		if (cookieJar) {
 			const jarCookies = await cookieJar.getCookies(options.url);
 			if (jarCookies) {
@@ -1203,19 +1516,12 @@ class Curl {
 			'%{stderr}===<json>==={"json":%{json},"headers":%{header_json}}===</json>===',
 		];
 
-		if (body) {
-			args.push('--data-raw', body);
-		}
-
-		const cookieHeader = await this.getCookieHeader();
-		if (cookieHeader) {
-			this.header('cookie', cookieHeader);
+		const cliOptions = options.cliOptions;
+		if (cliOptions) {
+			args.push(...cliOptions);
 		}
 
-		for (const [key, value] of Object.entries(options.headers)) {
-			args.push('--header', `${key}: ${value}`);
-		}
-		if (options.compress) {
+		if (options.compress && !cliOptions?.includes('--compressed')) {
 			args.push('--compressed');
 		}
 		if (options.proxy && options.useProxy !== false) {
@@ -1237,9 +1543,17 @@ class Curl {
 			args.push('--verbose');
 		}
 
-		const cliOptions = options.cliOptions;
-		if (cliOptions) {
-			args.push(...cliOptions);
+		const cookieHeader = await this.getCookieHeader();
+		if (cookieHeader) {
+			this.header('cookie', cookieHeader);
+		}
+
+		for (const [key, value] of Object.entries(options.headers)) {
+			args.push('--header', `${key}: ${value}`);
+		}
+
+		if (body) {
+			args.push('--data-raw', body);
 		}
 
 		return args;
@@ -1247,18 +1561,28 @@ class Curl {
 
 	async fetch() {
 		const startTime = Date.now();
-		const cmd = this.options.cliCommand || 'curl';
+		const options = this.options;
+		const cmd = options.cliCommand || 'curl';
 		const args = await this.getCurlArgs();
 		const curl = spawn(cmd, args);
-		const cookieJar = this.options.cookieJar;
+		const cookieJar = this._cookieJar;
 
-		let stdout = '';
+		let stdout = options.asBuffer ? Buffer.from([]) : '';
 		let stderr = '';
-		const response = new CurlResponse();
+		const response = new CurlResponse({
+			body: options.asBuffer ? Buffer.from([]) : '',
+		});
 		return new Promise((resolve, reject) => {
-			curl.stdout.on('data', (data) => {
-				stdout += data;
-			});
+			if (options.asBuffer) {
+				curl.stdout.on('data', (data) => {
+					stdout = Buffer.concat([stdout, data]);
+				});
+			}
+			else {
+				curl.stdout.on('data', (data) => {
+					stdout += data;
+				});
+			}
 
 			curl.stderr.on('data', (data) => {
 				stderr += data;
@@ -1272,7 +1596,7 @@ class Curl {
 			curl.on('close', async (code) => {
 				response.timeTaken = Date.now() - startTime;
 				response.exitCode = code;
-				response.url = this.options.url;
+				response.url = options.url;
 				response.body = stdout;
 				stderr = stderr.replace(/===<json>===(.*)===<\/json>===/s, (match, p1) => {
 					try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "curl-wrap",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Nodejs library that wraps curl command line",
   "main": "index.js",
   "types": "index.d.ts",