onbuzz 3.3.0

package/src/utilities/humanBehavior.js

@@ -0,0 +1,453 @@
+/**
+ * Human Behavior Simulation Utility
+ *
+ * Provides human-like mouse movements, typing patterns, and action delays
+ * to make browser automation less detectable by anti-bot systems.
+ */
+
+import { createCursor } from 'ghost-cursor';
+import {
+  TYPING_CONFIG,
+  MOUSE_CONFIG,
+  ACTION_DELAYS
+} from './stealthConstants.js';
+
+/**
+ * Generate a random number within a range
+ * @param {number} min - Minimum value
+ * @param {number} max - Maximum value
+ * @returns {number} Random number between min and max
+ */
+function randomInRange(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * Sleep for a specified duration
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Create a human-like cursor controller for a page
+ * @param {Page} page - Puppeteer page instance
+ * @param {Object} options - Cursor options
+ * @returns {Object} Ghost cursor instance with enhanced methods
+ */
+export function createHumanCursor(page, options = {}) {
+  const cursor = createCursor(page, {
+    // Start position (center of viewport)
+    start: {
+      x: Math.floor(page.viewport()?.width || 1920) / 2,
+      y: Math.floor(page.viewport()?.height || 1080) / 2
+    }
+  });
+
+  // Wrap cursor with human-like enhancements
+  return {
+    /**
+     * Move cursor to element with human-like motion
+     * @param {string} selector - CSS selector
+     * @param {Object} moveOptions - Movement options
+     */
+    async moveTo(selector, moveOptions = {}) {
+      const {
+        hesitate = true,
+        hesitateMs = randomInRange(
+          MOUSE_CONFIG.HESITATE_BEFORE_CLICK.MIN_MS,
+          MOUSE_CONFIG.HESITATE_BEFORE_CLICK.MAX_MS
+        )
+      } = moveOptions;
+
+      await cursor.move(selector);
+
+      if (hesitate) {
+        await sleep(hesitateMs);
+      }
+    },
+
+    /**
+     * Click element with human-like behavior
+     * @param {string} selector - CSS selector
+     * @param {Object} clickOptions - Click options
+     */
+    async click(selector, clickOptions = {}) {
+      const {
+        hesitate = true,
+        moveFirst = true
+      } = clickOptions;
+
+      if (moveFirst) {
+        await this.moveTo(selector, { hesitate });
+      }
+
+      // Random click duration
+      const clickDelay = randomInRange(
+        MOUSE_CONFIG.CLICK_DURATION.MIN_MS,
+        MOUSE_CONFIG.CLICK_DURATION.MAX_MS
+      );
+
+      await cursor.click(selector, {
+        hesitate: hesitate ? randomInRange(
+          MOUSE_CONFIG.HESITATE_BEFORE_CLICK.MIN_MS,
+          MOUSE_CONFIG.HESITATE_BEFORE_CLICK.MAX_MS
+        ) : 0,
+        waitForClick: clickDelay
+      });
+    },
+
+    /**
+     * Double click element with human-like behavior
+     * @param {string} selector - CSS selector
+     */
+    async doubleClick(selector) {
+      await this.moveTo(selector);
+      await cursor.click(selector, { waitForClick: 50 });
+      await sleep(randomInRange(50, 150));
+      await cursor.click(selector, { waitForClick: 50 });
+    },
+
+    /**
+     * Hover over element
+     * @param {string} selector - CSS selector
+     */
+    async hover(selector) {
+      await this.moveTo(selector, { hesitate: true });
+    },
+
+    /**
+     * Random mouse movement within viewport (simulates idle behavior)
+     * @param {number} duration - Duration in ms for random movements
+     */
+    async randomMovement(duration = 2000) {
+      const startTime = Date.now();
+      const viewport = page.viewport() || { width: 1920, height: 1080 };
+
+      while (Date.now() - startTime < duration) {
+        const x = randomInRange(100, viewport.width - 100);
+        const y = randomInRange(100, viewport.height - 100);
+
+        await cursor.moveTo({ x, y });
+        await sleep(randomInRange(200, 500));
+      }
+    },
+
+    // Expose original cursor for advanced use
+    _cursor: cursor
+  };
+}
+
+/**
+ * Type text with human-like patterns
+ * @param {Page} page - Puppeteer page instance
+ * @param {string} selector - CSS selector for input field
+ * @param {string} text - Text to type
+ * @param {Object} options - Typing options
+ */
+export async function humanType(page, selector, text, options = {}) {
+  const {
+    clearFirst = true,
+    clickFirst = true,
+    baseDelay = TYPING_CONFIG.BASE_DELAY_MS,
+    randomDelay = TYPING_CONFIG.RANDOM_DELAY_MAX_MS,
+    pauseProbability = TYPING_CONFIG.PAUSE_PROBABILITY,
+    simulateTypos = false,
+    typoProbability = TYPING_CONFIG.TYPO_PROBABILITY
+  } = options;
+
+  // Click to focus the field
+  if (clickFirst) {
+    await page.click(selector);
+    await sleep(randomInRange(100, 200));
+  }
+
+  // Clear existing content using keyboard commands (triggers proper input events)
+  // IMPORTANT: Setting element.value = '' directly does NOT trigger input events,
+  // which breaks React/Vue/Angular forms and can be detected as bot behavior.
+  if (clearFirst) {
+    // Triple-click to select all text in the field (more human-like than Ctrl+A)
+    await page.click(selector, { clickCount: 3 });
+    await sleep(randomInRange(50, 100));
+
+    // Delete selected text with Backspace (triggers input events)
+    await page.keyboard.press('Backspace');
+    await sleep(randomInRange(50, 100));
+
+    // Dispatch input event to ensure framework state updates
+    await page.evaluate((sel) => {
+      const element = document.querySelector(sel);
+      if (element) {
+        element.dispatchEvent(new Event('input', { bubbles: true }));
+        element.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+    }, selector);
+    await sleep(randomInRange(30, 80));
+  }
+
+  // Type each character with human-like timing
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+
+    // Occasional typo simulation
+    if (simulateTypos && Math.random() < typoProbability && char.match(/[a-z]/i)) {
+      // Type wrong key
+      const wrongChar = getAdjacentKey(char);
+      await page.keyboard.type(wrongChar);
+      await sleep(randomInRange(100, 200));
+
+      // Pause (realize mistake)
+      await sleep(randomInRange(200, 400));
+
+      // Delete wrong character
+      await page.keyboard.press('Backspace');
+      await sleep(TYPING_CONFIG.TYPO_CORRECTION_DELAY_MS);
+    }
+
+    // Type the correct character
+    await page.keyboard.type(char);
+
+    // Calculate delay for next character
+    let delay = baseDelay + randomInRange(0, randomDelay);
+
+    // Add occasional pauses (thinking)
+    if (Math.random() < pauseProbability) {
+      delay += randomInRange(
+        TYPING_CONFIG.PAUSE_DURATION.MIN_MS,
+        TYPING_CONFIG.PAUSE_DURATION.MAX_MS
+      );
+    }
+
+    // Slightly longer delay after punctuation or spaces
+    if (['.', ',', '!', '?', ' ', '@'].includes(char)) {
+      delay += randomInRange(30, 80);
+    }
+
+    await sleep(delay);
+  }
+
+  // Final event dispatch to ensure framework state is fully updated
+  // Some frameworks (especially React with controlled inputs) need explicit events
+  await page.evaluate((sel) => {
+    const element = document.querySelector(sel);
+    if (element) {
+      // Dispatch events that frameworks listen for
+      element.dispatchEvent(new Event('input', { bubbles: true }));
+      element.dispatchEvent(new Event('change', { bubbles: true }));
+      // Also dispatch blur and focus to trigger validation
+      element.dispatchEvent(new FocusEvent('blur', { bubbles: true }));
+      element.dispatchEvent(new FocusEvent('focus', { bubbles: true }));
+    }
+  }, selector);
+}
+
+/**
+ * Get an adjacent key on QWERTY keyboard for typo simulation
+ * @param {string} char - Original character
+ * @returns {string} Adjacent character
+ */
+function getAdjacentKey(char) {
+  const keyboard = {
+    'q': ['w', 'a'], 'w': ['q', 'e', 's'], 'e': ['w', 'r', 'd'], 'r': ['e', 't', 'f'],
+    't': ['r', 'y', 'g'], 'y': ['t', 'u', 'h'], 'u': ['y', 'i', 'j'], 'i': ['u', 'o', 'k'],
+    'o': ['i', 'p', 'l'], 'p': ['o', 'l'],
+    'a': ['q', 's', 'z'], 's': ['a', 'w', 'd', 'x'], 'd': ['s', 'e', 'f', 'c'],
+    'f': ['d', 'r', 'g', 'v'], 'g': ['f', 't', 'h', 'b'], 'h': ['g', 'y', 'j', 'n'],
+    'j': ['h', 'u', 'k', 'm'], 'k': ['j', 'i', 'l'], 'l': ['k', 'o', 'p'],
+    'z': ['a', 's', 'x'], 'x': ['z', 's', 'd', 'c'], 'c': ['x', 'd', 'f', 'v'],
+    'v': ['c', 'f', 'g', 'b'], 'b': ['v', 'g', 'h', 'n'], 'n': ['b', 'h', 'j', 'm'],
+    'm': ['n', 'j', 'k']
+  };
+
+  const lowerChar = char.toLowerCase();
+  const adjacent = keyboard[lowerChar];
+
+  if (!adjacent) return char;
+
+  const wrongChar = adjacent[Math.floor(Math.random() * adjacent.length)];
+  return char === char.toUpperCase() ? wrongChar.toUpperCase() : wrongChar;
+}
+
+/**
+ * Wait with human-like timing after an action
+ * @param {string} actionType - Type of action (navigation, action, submit)
+ * @returns {Promise<void>}
+ */
+export async function humanWait(actionType = 'action') {
+  let delay;
+
+  switch (actionType) {
+    case 'navigation':
+      delay = randomInRange(
+        ACTION_DELAYS.AFTER_NAVIGATION_MS.MIN,
+        ACTION_DELAYS.AFTER_NAVIGATION_MS.MAX
+      );
+      break;
+    case 'submit':
+    case 'beforeSubmit':
+      delay = randomInRange(
+        ACTION_DELAYS.BEFORE_SUBMIT_MS.MIN,
+        ACTION_DELAYS.BEFORE_SUBMIT_MS.MAX
+      );
+      break;
+    case 'afterSubmit':
+      delay = randomInRange(
+        ACTION_DELAYS.AFTER_SUBMIT_MS.MIN,
+        ACTION_DELAYS.AFTER_SUBMIT_MS.MAX
+      );
+      break;
+    case 'scroll':
+      delay = randomInRange(
+        ACTION_DELAYS.SCROLL_PAUSE_MS.MIN,
+        ACTION_DELAYS.SCROLL_PAUSE_MS.MAX
+      );
+      break;
+    case 'action':
+    default:
+      delay = randomInRange(
+        ACTION_DELAYS.BETWEEN_ACTIONS_MS.MIN,
+        ACTION_DELAYS.BETWEEN_ACTIONS_MS.MAX
+      );
+      break;
+  }
+
+  await sleep(delay);
+}
+
+/**
+ * Scroll page with human-like behavior
+ * @param {Page} page - Puppeteer page instance
+ * @param {Object} options - Scroll options
+ */
+export async function humanScroll(page, options = {}) {
+  const {
+    direction = 'down',
+    distance = 300,
+    steps = 5
+  } = options;
+
+  const stepDistance = Math.floor(distance / steps);
+  const scrollMultiplier = direction === 'up' ? -1 : 1;
+
+  for (let i = 0; i < steps; i++) {
+    // Add slight variation to each step
+    const actualStep = stepDistance + randomInRange(-20, 20);
+
+    await page.evaluate((y) => {
+      window.scrollBy({ top: y, behavior: 'smooth' });
+    }, actualStep * scrollMultiplier);
+
+    // Random pause between scroll steps
+    await sleep(randomInRange(50, 150));
+  }
+
+  // Pause after scrolling
+  await humanWait('scroll');
+}
+
+/**
+ * Scroll element into view with human-like behavior
+ * @param {Page} page - Puppeteer page instance
+ * @param {string} selector - CSS selector
+ */
+export async function scrollToElement(page, selector) {
+  await page.evaluate((sel) => {
+    const element = document.querySelector(sel);
+    if (element) {
+      element.scrollIntoView({ behavior: 'smooth', block: 'center' });
+    }
+  }, selector);
+
+  await humanWait('scroll');
+}
+
+/**
+ * Fill a form with human-like behavior
+ * @param {Page} page - Puppeteer page instance
+ * @param {Object} fields - Form fields { selector: value }
+ * @param {Object} options - Fill options
+ */
+export async function humanFillForm(page, fields, options = {}) {
+  const {
+    cursor = null,
+    tabBetweenFields = false
+  } = options;
+
+  const fieldEntries = Object.entries(fields);
+
+  for (let i = 0; i < fieldEntries.length; i++) {
+    const [selector, value] = fieldEntries[i];
+
+    // Move to field (if cursor provided)
+    if (cursor) {
+      await cursor.click(selector);
+    } else {
+      await page.click(selector);
+    }
+
+    await humanWait('action');
+
+    // Type the value
+    await humanType(page, selector, value, {
+      clearFirst: true,
+      clickFirst: false // Already clicked
+    });
+
+    // Wait between fields
+    if (i < fieldEntries.length - 1) {
+      await humanWait('action');
+
+      // Optionally use Tab to move to next field
+      if (tabBetweenFields) {
+        await page.keyboard.press('Tab');
+        await sleep(randomInRange(100, 200));
+      }
+    }
+  }
+}
+
+/**
+ * Submit a form with human-like behavior
+ * @param {Page} page - Puppeteer page instance
+ * @param {string} submitSelector - CSS selector for submit button
+ * @param {Object} options - Submit options
+ */
+export async function humanSubmit(page, submitSelector, options = {}) {
+  const { cursor = null, waitForNavigation = true } = options;
+
+  // Pause before submit (human would review)
+  await humanWait('beforeSubmit');
+
+  // Click submit
+  if (cursor) {
+    await cursor.click(submitSelector);
+  } else {
+    await page.click(submitSelector);
+  }
+
+  // Wait for navigation if expected
+  if (waitForNavigation) {
+    try {
+      await page.waitForNavigation({
+        timeout: 10000,
+        waitUntil: 'networkidle2'
+      });
+    } catch (e) {
+      // Navigation might not happen (AJAX form)
+    }
+  }
+
+  await humanWait('afterSubmit');
+}
+
+export default {
+  createHumanCursor,
+  humanType,
+  humanWait,
+  humanScroll,
+  scrollToElement,
+  humanFillForm,
+  humanSubmit
+};

package/src/utilities/jsonRepair.js

@@ -0,0 +1,242 @@
+/**
+ * JSON Repair Utility
+ *
+ * Handles parsing of potentially truncated or malformed JSON from AI responses.
+ * Uses jsonrepair library to fix common issues like:
+ * - Missing closing brackets/braces
+ * - Truncated strings
+ * - Missing commas
+ * - Trailing commas
+ */
+
+import { jsonrepair } from 'jsonrepair';
+
+/**
+ * Parse JSON with automatic repair for truncated/malformed content
+ * @param {string} jsonString - The JSON string to parse
+ * @param {Object} options - Options
+ * @param {boolean} options.silent - If true, don't log warnings
+ * @returns {Object} { data, wasRepaired, original, repaired, error }
+ */
+export function parseJSONWithRepair(jsonString, options = {}) {
+  const result = {
+    data: null,
+    wasRepaired: false,
+    wasTruncated: false,
+    original: jsonString,
+    repaired: null,
+    error: null
+  };
+
+  // First, try standard JSON.parse
+  try {
+    result.data = JSON.parse(jsonString);
+    return result;
+  } catch (originalError) {
+    // Standard parse failed, try repair
+    try {
+      const repairedString = jsonrepair(jsonString);
+      result.repaired = repairedString;
+      result.data = JSON.parse(repairedString);
+      result.wasRepaired = true;
+
+      // Detect if it was likely truncated (common patterns)
+      result.wasTruncated = detectTruncation(jsonString, repairedString);
+
+      if (!options.silent) {
+        console.warn('[JSONRepair] Repaired malformed JSON:', {
+          originalLength: jsonString.length,
+          repairedLength: repairedString.length,
+          wasTruncated: result.wasTruncated
+        });
+      }
+
+      return result;
+    } catch (repairError) {
+      // Even repair failed
+      result.error = {
+        originalError: originalError.message,
+        repairError: repairError.message
+      };
+      return result;
+    }
+  }
+}
+
+/**
+ * Detect if JSON was truncated (vs just malformed)
+ * Uses state machine approach for accurate string tracking
+ * @param {string} original - Original JSON string
+ * @param {string} repaired - Repaired JSON string
+ * @returns {boolean} True if likely truncated
+ */
+function detectTruncation(original, repaired) {
+  const trimmed = original.trim();
+
+  // State machine to accurately track JSON structure
+  let depth = 0;        // Bracket nesting depth
+  let inString = false; // Currently inside a string
+  let escaped = false;  // Previous char was escape
+
+  for (const char of trimmed) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === '\\' && inString) {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+
+    if (char === '{' || char === '[') depth++;
+    if (char === '}' || char === ']') depth--;
+  }
+
+  // PRIMARY CHECK: If we end mid-string, definitely truncated
+  // This catches the common case where content was cut off mid-sentence
+  if (inString) {
+    console.log('[JSONRepair] Truncation detected: ended mid-string');
+    return true;
+  }
+
+  // If we have unclosed brackets, truncated
+  if (depth > 0) {
+    console.log('[JSONRepair] Truncation detected: unclosed brackets, depth=' + depth);
+    return true;
+  }
+
+  // If we end mid-escape sequence, truncated
+  if (escaped) {
+    console.log('[JSONRepair] Truncation detected: ended mid-escape');
+    return true;
+  }
+
+  // Count bracket differences between original and repaired
+  const countBrackets = (str) => {
+    let open = 0, close = 0;
+    let inStr = false, esc = false;
+    for (const char of str) {
+      if (esc) { esc = false; continue; }
+      if (char === '\\' && inStr) { esc = true; continue; }
+      if (char === '"') { inStr = !inStr; continue; }
+      if (inStr) continue;
+      if (char === '{' || char === '[') open++;
+      if (char === '}' || char === ']') close++;
+    }
+    return { open, close };
+  };
+
+  const originalBrackets = countBrackets(original);
+  const repairedBrackets = countBrackets(repaired);
+
+  // If repair added closing brackets, it was truncated
+  if (repairedBrackets.close > originalBrackets.close) {
+    console.log('[JSONRepair] Truncation detected: repair added closing brackets');
+    return true;
+  }
+
+  // Check for common truncation patterns in the ending
+  const lastChars = trimmed.slice(-20);
+  const truncationPatterns = [
+    /,\s*$/,           // Ends with comma (expecting more)
+    /:\s*$/,           // Ends with colon (expecting value)
+    /\[\s*$/,          // Ends with open bracket
+    /\{\s*$/,          // Ends with open brace
+  ];
+
+  for (const pattern of truncationPatterns) {
+    if (pattern.test(lastChars)) {
+      console.log('[JSONRepair] Truncation detected: suspicious ending pattern');
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if a string looks like it might be truncated JSON
+ * Useful for pre-checking before attempting parse
+ * @param {string} str - String to check
+ * @returns {boolean} True if likely truncated
+ */
+export function looksLikeTruncatedJSON(str) {
+  const trimmed = str.trim();
+
+  // Must start with { or [ to be JSON
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+    return false;
+  }
+
+  // Check for balanced brackets
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (const char of trimmed) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === '\\' && inString) {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+
+    if (char === '{' || char === '[') depth++;
+    if (char === '}' || char === ']') depth--;
+  }
+
+  // If depth > 0, we have unclosed brackets (truncated)
+  // If inString is true, we're mid-string (truncated)
+  return depth > 0 || inString;
+}
+
+/**
+ * Create a truncation notice for file content
+ * @param {string} fileType - Type of file (md, js, etc.)
+ * @returns {string} Truncation notice
+ */
+export function createTruncationNotice(fileType) {
+  const notices = {
+    md: '\n\n---\n**[CONTENT TRUNCATED]** - AI response exceeded token limit. Content above this line may be incomplete.\n',
+    js: '\n\n// [CONTENT TRUNCATED] - AI response exceeded token limit. Content above this line may be incomplete.\n',
+    ts: '\n\n// [CONTENT TRUNCATED] - AI response exceeded token limit. Content above this line may be incomplete.\n',
+    jsx: '\n\n// [CONTENT TRUNCATED] - AI response exceeded token limit. Content above this line may be incomplete.\n',
+    tsx: '\n\n// [CONTENT TRUNCATED] - AI response exceeded token limit. Content above this line may be incomplete.\n',
+    json: '', // Can't add comments to JSON
+    css: '\n\n/* [CONTENT TRUNCATED] - AI response exceeded token limit. Content above this line may be incomplete. */\n',
+    html: '\n\n<!-- [CONTENT TRUNCATED] - AI response exceeded token limit. Content above this line may be incomplete. -->\n',
+    py: '\n\n# [CONTENT TRUNCATED] - AI response exceeded token limit. Content above this line may be incomplete.\n',
+    default: '\n\n[CONTENT TRUNCATED] - AI response exceeded token limit.\n'
+  };
+
+  return notices[fileType] || notices.default;
+}
+
+/**
+ * Get file extension from path
+ * @param {string} filePath - File path
+ * @returns {string} Extension without dot
+ */
+export function getFileExtension(filePath) {
+  const match = filePath.match(/\.([^.]+)$/);
+  return match ? match[1].toLowerCase() : '';
+}
+
+export default {
+  parseJSONWithRepair,
+  looksLikeTruncatedJSON,
+  createTruncationNotice,
+  getFileExtension
+};