@theihtisham/devtools-with-cloud 1.0.0

package/src/lib/importers/curl-parser.ts

@@ -0,0 +1,346 @@
+import type { HttpMethod } from '@/lib/utils/validation';
+
+export interface ParsedCurl {
+  method: HttpMethod;
+  url: string;
+  headers: { key: string; value: string; enabled: boolean }[];
+  params: { key: string; value: string; enabled: boolean }[];
+  body?: string;
+  bodyType?: string;
+  auth?: unknown;
+  name?: string;
+}
+
+/**
+ * Parse a cURL command string into a structured request object.
+ * Handles common cURL flags: -X, -H, -d, --data, --data-raw, -F, -u, -b, etc.
+ */
+export function parseCurl(command: string): ParsedCurl {
+  const tokens = tokenizeCurl(command);
+
+  if (tokens.length === 0) {
+    throw new Error('Empty cURL command');
+  }
+
+  // Remove 'curl' from the start if present
+  if (tokens[0]?.toLowerCase() === 'curl') {
+    tokens.shift();
+  }
+
+  let method: HttpMethod = 'GET';
+  let url = '';
+  const headers: ParsedCurl['headers'] = [];
+  const params: ParsedCurl['params'] = [];
+  let body: string | undefined;
+  let bodyType: string | undefined;
+  let auth: unknown;
+  let hasData = false;
+
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+
+    if (token === undefined) { i++; continue; }
+
+    switch (token) {
+      // Method
+      case '-X':
+      case '--request': {
+        const val = tokens[++i];
+        if (val) method = val.toUpperCase() as HttpMethod;
+        break;
+      }
+
+      // Headers
+      case '-H':
+      case '--header': {
+        const headerStr = tokens[++i];
+        if (headerStr) {
+          const colonIndex = headerStr.indexOf(':');
+          if (colonIndex > 0) {
+            const key = headerStr.slice(0, colonIndex).trim();
+            const value = headerStr.slice(colonIndex + 1).trim();
+            headers.push({ key, value, enabled: true });
+          }
+        }
+        break;
+      }
+
+      // Data
+      case '-d':
+      case '--data':
+      case '--data-raw':
+      case '--data-binary': {
+        const dataVal = tokens[++i];
+        if (dataVal) {
+          body = dataVal;
+          hasData = true;
+
+          // Determine body type
+          if (dataVal.trim().startsWith('{') || dataVal.trim().startsWith('[')) {
+            bodyType = 'json';
+          } else if (dataVal.includes('=') && !dataVal.startsWith('@')) {
+            bodyType = 'urlencoded';
+          } else {
+            bodyType = 'raw';
+          }
+
+          // Default to POST when data is present
+          if (method === 'GET') method = 'POST';
+        }
+        break;
+      }
+
+      // Form data
+      case '-F':
+      case '--form': {
+        const formVal = tokens[++i];
+        if (formVal) {
+          bodyType = 'form';
+          if (!body) body = formVal;
+          else body += `&${formVal}`;
+
+          if (method === 'GET') method = 'POST';
+          hasData = true;
+        }
+        break;
+      }
+
+      // User (Basic Auth)
+      case '-u':
+      case '--user': {
+        const userVal = tokens[++i];
+        if (userVal) {
+          const colonIndex = userVal.indexOf(':');
+          if (colonIndex > 0) {
+            auth = {
+              type: 'basic',
+              username: userVal.slice(0, colonIndex),
+              password: userVal.slice(colonIndex + 1),
+            };
+          } else {
+            auth = { type: 'basic', username: userVal, password: '' };
+          }
+        }
+        break;
+      }
+
+      // Bearer token
+      case '--oauth2-bearer': {
+        const tokenVal = tokens[++i];
+        if (tokenVal) {
+          auth = { type: 'bearer', token: tokenVal, prefix: 'Bearer' };
+        }
+        break;
+      }
+
+      // Cookies
+      case '-b':
+      case '--cookie': {
+        const cookieVal = tokens[++i];
+        if (cookieVal) {
+          headers.push({ key: 'Cookie', value: cookieVal, enabled: true });
+        }
+        break;
+      }
+
+      // Follow redirects
+      case '-L':
+      case '--location':
+        // Note: we'd set followRedirects = true on the request config
+        break;
+
+      // Insecure SSL
+      case '-k':
+      case '--insecure':
+        // Note: we'd set verifySSL = false on the request config
+        break;
+
+      // Silent/verbose (ignore)
+      case '-s':
+      case '--silent':
+      case '-v':
+      case '--verbose':
+      case '-S':
+      case '--show-error':
+        break;
+
+      // Output file (ignore)
+      case '-o':
+      case '--output':
+        i++; // Skip the filename
+        break;
+
+      // Max time
+      case '-m':
+      case '--max-time':
+        i++; // Skip the time value
+        break;
+
+      // Connection timeout
+      case '--connect-timeout':
+        i++; // Skip the time value
+        break;
+
+      // User agent
+      case '-A':
+      case '--user-agent': {
+        const uaVal = tokens[++i];
+        if (uaVal) {
+          headers.push({ key: 'User-Agent', value: uaVal, enabled: true });
+        }
+        break;
+      }
+
+      // No default method override
+      case '--compressed':
+        headers.push({ key: 'Accept-Encoding', value: 'gzip, deflate', enabled: true });
+        break;
+
+      default:
+        // URL (first non-flag argument)
+        if (!token.startsWith('-') && !url) {
+          url = token;
+
+          // Remove quotes if present
+          if ((url.startsWith("'") && url.endsWith("'")) || (url.startsWith('"') && url.endsWith('"'))) {
+            url = url.slice(1, -1);
+          }
+        }
+        break;
+    }
+
+    i++;
+  }
+
+  if (!url) {
+    throw new Error('No URL found in cURL command');
+  }
+
+  // Parse query params from URL
+  try {
+    const urlObj = new URL(url);
+    urlObj.searchParams.forEach((value, key) => {
+      params.push({ key, value, enabled: true });
+    });
+    // Use URL without query string for cleaner display
+    url = urlObj.origin + urlObj.pathname;
+  } catch {
+    // URL might have variables, keep as-is
+  }
+
+  return {
+    method,
+    url,
+    headers,
+    params,
+    body,
+    bodyType,
+    auth,
+  };
+}
+
+/**
+ * Tokenize a cURL command string respecting quotes and escaped characters.
+ */
+function tokenizeCurl(command: string): string[] {
+  const tokens: string[] = [];
+  let current = '';
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+
+    if (char === undefined) continue;
+
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === '\\') {
+      if (inSingleQuote) {
+        current += char;
+      } else {
+        escaped = true;
+      }
+      continue;
+    }
+
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+
+    if (char === ' ' && !inSingleQuote && !inDoubleQuote) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = '';
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+
+  return tokens;
+}
+
+/**
+ * Generate a cURL command from request data.
+ */
+export function generateCurl(request: {
+  method: string;
+  url: string;
+  headers?: { key: string; value: string; enabled: boolean }[];
+  body?: string;
+  bodyType?: string;
+  auth?: unknown;
+}): string {
+  const parts: string[] = [`curl -X ${request.method}`];
+
+  // URL
+  const quotedUrl = request.url.includes(' ')
+    ? `'${request.url}'`
+    : request.url;
+  parts.push(quotedUrl);
+
+  // Headers
+  if (request.headers) {
+    for (const h of request.headers) {
+      if (h.enabled && h.key) {
+        parts.push(`-H '${h.key}: ${h.value}'`);
+      }
+    }
+  }
+
+  // Auth
+  if (request.auth) {
+    const auth = request.auth as Record<string, string>;
+    if (auth['type'] === 'basic') {
+      parts.push(`-u '${auth['username']}:${auth['password']}'`);
+    } else if (auth['type'] === 'bearer') {
+      parts.push(`-H 'Authorization: Bearer ${auth['token']}'`);
+    }
+  }
+
+  // Body
+  if (request.body) {
+    const bodyStr = request.body.replace(/'/g, "'\\''");
+    parts.push(`--data-raw '${bodyStr}'`);
+  }
+
+  return parts.join(' \\\n  ');
+}

package/src/lib/importers/har-parser.ts

@@ -0,0 +1,128 @@
+import type { HttpMethod } from '@/lib/utils/validation';
+
+export interface ImportedHarEntry {
+  name: string;
+  method: HttpMethod;
+  url: string;
+  status: number;
+  statusText: string;
+  headers: { key: string; value: string; enabled: boolean }[];
+  params: { key: string; value: string; enabled: boolean }[];
+  body?: string;
+  bodyType?: string;
+  responseHeaders: { key: string; value: string }[];
+  responseBody?: string;
+  responseStatus: number;
+  responseStatusText: string;
+  timing: number;
+  startedDateTime: string;
+}
+
+export interface ImportedHar {
+  entries: ImportedHarEntry[];
+}
+
+/**
+ * Import an HAR (HTTP Archive) file.
+ */
+export function importHar(harJson: string): ImportedHar {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(harJson);
+  } catch {
+    throw new Error('Invalid HAR file: must be valid JSON');
+  }
+
+  const har = parsed as Record<string, unknown>;
+  const log = har['log'] as Record<string, unknown> | undefined;
+
+  if (!log) {
+    throw new Error('Invalid HAR file: missing "log" object');
+  }
+
+  const entries = log['entries'] as Array<Record<string, unknown>> | undefined;
+
+  if (!entries || !Array.isArray(entries)) {
+    throw new Error('Invalid HAR file: missing "entries" array');
+  }
+
+  const result: ImportedHar = { entries: [] };
+
+  for (const entry of entries) {
+    const request = entry['request'] as Record<string, unknown> | undefined;
+    const response = entry['response'] as Record<string, unknown> | undefined;
+    const time = entry['time'] as number ?? 0;
+    const startedDateTime = entry['startedDateTime'] as string ?? '';
+
+    if (!request) continue;
+
+    const method = (request['method'] as string ?? 'GET').toUpperCase() as HttpMethod;
+    const url = request['url'] as string ?? '';
+    const headers = parseHarHeaders(request['headers'] as Array<Record<string, string>>);
+    const params = parseHarParams(request['queryString'] as Array<Record<string, string>>);
+
+    let body: string | undefined;
+    let bodyType: string | undefined;
+
+    const postData = request['postData'] as Record<string, unknown> | undefined;
+    if (postData) {
+      body = postData['text'] as string ?? '';
+      const mimeType = postData['mimeType'] as string ?? '';
+      if (mimeType.includes('json')) bodyType = 'json';
+      else if (mimeType.includes('urlencoded')) bodyType = 'urlencoded';
+      else if (mimeType.includes('form-data')) bodyType = 'form';
+      else bodyType = 'raw';
+    }
+
+    const responseHeaders = parseHarResponseHeaders(response?.['headers'] as Array<Record<string, string>>);
+    const responseBody = response?.['content'] as Record<string, unknown>;
+    const responseStatus = response?.['status'] as number ?? 0;
+    const responseStatusText = response?.['statusText'] as string ?? '';
+
+    result.entries.push({
+      name: `${method} ${new URL(url).pathname}`,
+      method,
+      url,
+      status: responseStatus,
+      statusText: responseStatusText,
+      headers,
+      params,
+      body,
+      bodyType,
+      responseHeaders,
+      responseBody: responseBody?.['text'] as string,
+      responseStatus,
+      responseStatusText,
+      timing: time,
+      startedDateTime,
+    });
+  }
+
+  return result;
+}
+
+function parseHarHeaders(headers: Array<Record<string, string>> | undefined): { key: string; value: string; enabled: boolean }[] {
+  if (!headers || !Array.isArray(headers)) return [];
+  return headers.map((h) => ({
+    key: h['name'] ?? '',
+    value: h['value'] ?? '',
+    enabled: true,
+  }));
+}
+
+function parseHarParams(params: Array<Record<string, string>> | undefined): { key: string; value: string; enabled: boolean }[] {
+  if (!params || !Array.isArray(params)) return [];
+  return params.map((p) => ({
+    key: p['name'] ?? '',
+    value: p['value'] ?? '',
+    enabled: true,
+  }));
+}
+
+function parseHarResponseHeaders(headers: Array<Record<string, string>> | undefined): { key: string; value: string }[] {
+  if (!headers || !Array.isArray(headers)) return [];
+  return headers.map((h) => ({
+    key: h['name'] ?? '',
+    value: h['value'] ?? '',
+  }));
+}