index.js

#!/usr/bin/env node
// deletemytweets — Date-filtered tweet deletion tool for X (Twitter)
// Safely delete old tweets while protecting recent ones
// https://github.com/Kepners/deletemytweets

const fs = require("fs");
const path = require("path");
const { chromium, firefox } = require("playwright");

// Check if running in CLI mode (not embedded in Electron)
const IS_CLI = require.main === module;

// Modern UI libraries (only load for CLI mode)
let chalk, boxen, ora, cliProgress, figlet, gradient;
if (IS_CLI) {
  chalk = require("chalk");
  boxen = require("boxen");
  ora = require("ora");
  cliProgress = require("cli-progress");
  figlet = require("figlet");
  gradient = require("gradient-string");
} else {
  // Stubs for embedded mode - recursive proxy to handle any chain like chalk.red.bold.underline(text)
  const createChalkProxy = () => {
    const handler = {
      get: () => createChalkProxy(),
      apply: (target, thisArg, args) => args[0] || ''
    };
    return new Proxy(function(s) { return s || ''; }, handler);
  };
  chalk = createChalkProxy();

  // ora stub - returns spinner object with all methods
  ora = () => {
    const spinner = {
      start: () => spinner,
      stop: () => spinner,
      succeed: () => spinner,
      fail: () => spinner,
      warn: () => spinner,
      info: () => spinner,
      text: ''
    };
    return spinner;
  };

  // boxen stub
  boxen = (text) => text;

  // cliProgress stub
  cliProgress = {
    SingleBar: class { start() {} stop() {} update() {} },
    Presets: { shades_classic: {} }
  };

  // figlet stub
  figlet = { textSync: (s) => s };
}

// ================= TERMINAL UI =================
// Only create gradients in CLI mode
let xGradient, deleteGradient, successGradient;
if (IS_CLI) {
  xGradient = gradient(['#1DA1F2', '#14171A']); // Twitter blue to black
  deleteGradient = gradient(['#ff6b6b', '#ee5a24']);
  successGradient = gradient(['#2ecc71', '#27ae60']);
} else {
  xGradient = deleteGradient = successGradient = { multiline: (s) => s };
}

// ================= BROWSER CHECK =================
// Check if Edge or Chrome is installed for Playwright to use
function getBrowserChannel() {
  const edgePaths = [
    path.join(process.env.PROGRAMFILES || '', 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
    path.join(process.env['PROGRAMFILES(X86)'] || '', 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
    path.join(process.env.LOCALAPPDATA || '', 'Microsoft', 'Edge', 'Application', 'msedge.exe')
  ];

  const chromePaths = [
    path.join(process.env.PROGRAMFILES || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
    path.join(process.env['PROGRAMFILES(X86)'] || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
    path.join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'Application', 'chrome.exe')
  ];

  // Check for Edge first (preferred)
  for (const p of edgePaths) {
    if (fs.existsSync(p)) return 'msedge';
  }

  // Fallback to Chrome
  for (const p of chromePaths) {
    if (fs.existsSync(p)) return 'chrome';
  }

  return null; // No supported browser found
}

let BROWSER_CHANNEL = null; // Will be set at startup

function printHeader() {
  if (!IS_CLI) return;
  console.clear();
  console.log("");

  // ASCII art logo with gradient
  const logo = figlet.textSync('DeleteMyTweets', {
    font: 'Small',
    horizontalLayout: 'default'
  });
  console.log(xGradient(logo));

  // Tagline box
  const tagline = boxen(
    chalk.white.bold('Delete Old Tweets by Year') + '\n' +
    chalk.gray('Safely clean your Twitter history'),
    {
      padding: { top: 0, bottom: 0, left: 2, right: 2 },
      margin: { top: 0, bottom: 1, left: 0, right: 0 },
      borderStyle: 'round',
      borderColor: 'cyan',
      textAlignment: 'center'
    }
  );
  console.log(tagline);
}

function printConfig(config) {
  if (!IS_CLI) return;
  const { handle, target, posts, replies, reposts, speed } = config;
  const bounds = resolveDateBounds(config);
  const deleteDate = formatDate(bounds.deleteBefore);
  const protectDate = formatDate(bounds.protectAfter);
  const speedLabel = speed === 'aggressive' ? 'Aggressive' : speed === 'conservative' ? 'Conservative' : 'Normal';

  const configBox = boxen(
    chalk.bold.cyan('  CONFIGURATION\n') +
    chalk.gray('  ─────────────────────────────────\n') +
    `  ${chalk.cyan('Profile')}       ${chalk.white('@' + chalk.bold(handle))}\n` +
    `  ${chalk.cyan('Target')}        ${chalk.bold.white(target)} tweets\n` +
    `  ${chalk.cyan('Mode')}          ${chalk.white(describeDateBounds(config))}\n` +
    `  ${chalk.red('Delete')}        Before ${deleteDate}\n` +
    `  ${chalk.green('Protect')}       After ${protectDate}\n` +
    `  ${chalk.cyan('Speed')}         ${speedLabel}\n` +
    chalk.gray('  ─────────────────────────────────\n') +
    `  ${chalk.cyan('Posts')}         ${posts ? chalk.green('✓ YES') : chalk.gray('✗ NO')}\n` +
    `  ${chalk.cyan('Replies')}       ${replies ? chalk.green('✓ YES') : chalk.gray('✗ NO')}\n` +
    `  ${chalk.cyan('Reposts')}       ${reposts ? chalk.green('✓ YES') : chalk.gray('✗ NO')}`,
    {
      padding: 1,
      margin: { top: 0, bottom: 1, left: 0, right: 0 },
      borderStyle: 'round',
      borderColor: 'gray'
    }
  );
  console.log(configBox);
}

// Callback for GUI mode logging
let onLogCallback = null;

// Abort controller for stopping cleanup
let abortController = null;

function isAborted() {
  return abortController && abortController.signal.aborted;
}

function abortCleanup() {
  if (abortController) {
    abortController.abort();
  }
}

function log(type, message, extra = "") {
  const plainMessage = `${message}${extra ? ' ' + extra : ''}`;

  // Send to GUI callback if set
  if (onLogCallback) {
    onLogCallback({ type, message: plainMessage });
  }

  // Only show in CLI mode
  if (!IS_CLI) return;

  const timestamp = chalk.gray(new Date().toLocaleTimeString("en-US", { hour12: false }));
  const icons = {
    info: chalk.blue('ℹ'),
    success: chalk.green('✓'),
    warn: chalk.yellow('⚠'),
    error: chalk.red('✗'),
    delete: chalk.red('🗑'),
    protect: chalk.green('🛡'),
    skip: chalk.gray('○'),
    tab: chalk.magenta('→'),
  };
  const icon = icons[type] || chalk.gray('·');
  const extraText = extra ? chalk.gray(` ${extra}`) : '';
  console.log(`${timestamp} ${icon} ${message}${extraText}`);
}

function emitEvent(type, payload = {}) {
  if (process.env.DMT_EMIT_EVENTS !== "true") return;
  try {
    console.log(`__DMT_EVENT__${JSON.stringify({ type, ...payload })}`);
  } catch {}
}

function printSummary(removed, target, startTime) {
  if (!IS_CLI) return;
  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
  const rate = removed > 0 ? (elapsed / removed).toFixed(1) : 0;
  const percent = Math.round((removed / target) * 100);

  console.log("");

  const summaryBox = boxen(
    successGradient.multiline('  COMPLETE!\n') +
    chalk.gray('  ═══════════════════════════════\n') +
    `  ${chalk.cyan('Deleted')}      ${chalk.bold.green(removed)} / ${target} (${percent}%)\n` +
    `  ${chalk.cyan('Time')}         ${elapsed} seconds\n` +
    `  ${chalk.cyan('Speed')}        ${rate}s per tweet\n` +
    chalk.gray('  ═══════════════════════════════'),
    {
      padding: 1,
      margin: 1,
      borderStyle: 'double',
      borderColor: 'green',
      title: '✓ Summary',
      titleAlignment: 'center'
    }
  );
  console.log(summaryBox);
}

// Progress bar instance
let progressBar = null;
// Callback for GUI mode
let onProgressCallback = null;

function createProgressBar(total) {
  if (!IS_CLI) return;
  progressBar = new cliProgress.SingleBar({
    format: '  {bar} | {percentage}% | {value}/{total} tweets | {tab}',
    barCompleteChar: '█',
    barIncompleteChar: '░',
    hideCursor: true,
    clearOnComplete: false,
    barsize: 25,
    forceRedraw: true
  }, cliProgress.Presets.shades_classic);
  progressBar.start(total, 0, { tab: '' });
}

function updateProgress(current, tab, total) {
  if (IS_CLI && progressBar) {
    progressBar.update(current, { tab });
  }
  if (onProgressCallback) {
    onProgressCallback({ current, total, tab });
  }
}

function stopProgress() {
  if (!IS_CLI) return;
  if (progressBar) {
    progressBar.stop();
    progressBar = null;
  }
}

// ================= CONFIG FILE =================
const CONFIG_FILE = path.resolve(__dirname, "deletemytweets_config.json");
const SESSION_EXPIRY_MS = 24 * 60 * 60 * 1000; // 24 hours
const HANDLE_PATTERN = /^[A-Za-z0-9_]{1,15}$/;
const ARCHIVE_START = new Date(2006, 0, 1);

function normalizeHandle(rawHandle) {
  if (typeof rawHandle !== "string") return null;
  const trimmed = rawHandle.trim().replace(/^@+/, "");
  if (!HANDLE_PATTERN.test(trimmed)) return null;
  return trimmed.toLowerCase();
}

function toPositiveInt(value, fallback) {
  const parsed = parseInt(value, 10);
  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
}

function toBoolean(value, fallback = false) {
  if (value === true || value === false) return value;
  if (typeof value === "string") {
    const normalized = value.trim().toLowerCase();
    if (normalized === "true") return true;
    if (normalized === "false") return false;
  }
  return fallback;
}

function normalizeSelectionMode(rawMode) {
  const mode = typeof rawMode === "string" ? rawMode.trim().toLowerCase() : "";
  if (
    mode === "protect" ||
    mode === "keep" ||
    mode === "keep_recent" ||
    mode === "keep-recent" ||
    mode === "rolling-keep"
  ) {
    return "protect";
  }
  if (
    mode === "delete" ||
    mode === "delete_recent" ||
    mode === "delete-recent" ||
    mode === "rolling-delete"
  ) {
    return "delete";
  }
  return "delete";
}

function startOfMonth(date = new Date()) {
  return new Date(date.getFullYear(), date.getMonth(), 1);
}

function shiftMonths(date, deltaMonths) {
  return new Date(date.getFullYear(), date.getMonth() + deltaMonths, 1);
}

function resolveDateBounds(options = {}) {
  const sliderMode = normalizeSelectionMode(options.sliderMode ?? SLIDER_MODE);
  const rollingWindow = toBoolean(options.rollingWindow ?? ROLLING_WINDOW);
  const rollingMonths = toPositiveInt(options.rollingMonths ?? ROLLING_MONTHS, 3);
  const deleteMonth = toPositiveInt(options.deleteMonth ?? DELETE_MONTH, 12);
  const deleteYear = toPositiveInt(options.deleteYear ?? DELETE_YEAR, 2014);
  const protectMonth = toPositiveInt(options.protectMonth ?? PROTECT_MONTH, 1);
  const protectYear = toPositiveInt(options.protectYear ?? PROTECT_YEAR, new Date().getFullYear());

  if (rollingWindow) {
    const currentMonth = startOfMonth(options.now || new Date());
    const windowStart = shiftMonths(currentMonth, -(rollingMonths - 1));
    const windowEndExclusive = shiftMonths(currentMonth, 1);
    return {
      sliderMode,
      rollingWindow: true,
      rollingMonths,
      deleteBefore: sliderMode === "protect" ? ARCHIVE_START : windowStart,
      protectAfter: sliderMode === "protect" ? windowStart : windowEndExclusive
    };
  }

  return {
    sliderMode,
    rollingWindow: false,
    rollingMonths,
    deleteBefore: sliderMode === "protect"
      ? ARCHIVE_START
      : new Date(deleteYear, deleteMonth - 1, 1),
    protectAfter: new Date(protectYear, protectMonth - 1, 1)
  };
}

function describeDateBounds(options = {}) {
  const bounds = resolveDateBounds(options);
  const { sliderMode, rollingWindow, rollingMonths, deleteBefore, protectAfter } = bounds;

  if (rollingWindow) {
    const displayStart = sliderMode === "protect" ? protectAfter : deleteBefore;
    const displayEnd = sliderMode === "protect"
      ? shiftMonths(protectAfter, rollingMonths - 1)
      : shiftMonths(protectAfter, -1);
    if (sliderMode === "protect") {
      return `Rolling keep recent ${rollingMonths} month${rollingMonths === 1 ? "" : "s"} (${formatDate(displayStart)} → ${formatDate(displayEnd)})`;
    }
    return `Rolling delete recent ${rollingMonths} month${rollingMonths === 1 ? "" : "s"} (${formatDate(displayStart)} → ${formatDate(displayEnd)})`;
  }

  if (sliderMode === "protect") {
    return `Keep after ${formatDate(protectAfter)}`
  }

  return `Delete from ${formatDate(deleteBefore)} to ${formatDate(protectAfter)}`;
}

function loadConfig() {
  try {
    if (fs.existsSync(CONFIG_FILE)) {
      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
    }
  } catch {}
  return {};
}

function saveConfig(config) {
  try {
    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
  } catch {}
}

// Get storage file path for specific handle
// Use app's userData folder in Electron, or __dirname for CLI
function getStoragePath(handle) {
  const normalizedHandle = normalizeHandle(handle);
  if (!normalizedHandle) return null;

  // Check if running in Electron
  let basePath = __dirname;
  try {
    const { app } = require('electron');
    if (app && app.getPath) {
      basePath = app.getPath('userData');
    }
  } catch {
    // Not in Electron main process, check if we can get userData from env
    if (process.env.ELECTRON_USER_DATA) {
      basePath = process.env.ELECTRON_USER_DATA;
    }
  }
  return path.resolve(basePath, `x_auth_${normalizedHandle}.json`);
}

// Check if session is valid (exists and not expired)
function isSessionValid(handle) {
  const storagePath = getStoragePath(handle);
  if (!storagePath) return false;
  if (!fs.existsSync(storagePath)) return false;

  try {
    const stat = fs.statSync(storagePath);
    const age = Date.now() - stat.mtimeMs;
    if (age > SESSION_EXPIRY_MS) {
      // Session expired, delete it
      fs.unlinkSync(storagePath);
      return false;
    }
    return true;
  } catch {
    return false;
  }
}

// Clear session for a handle
function clearSession(handle) {
  const storagePath = getStoragePath(handle);
  if (!storagePath) return;
  try {
    if (fs.existsSync(storagePath)) {
      fs.unlinkSync(storagePath);
    }
  } catch {}
}

const savedConfig = loadConfig();

// ================= CONFIG =================
// Speed presets for delay between deletions
const SPEED_PRESETS = {
  aggressive:   { min: 600, max: 1000 },   // Fast but risky
  normal:       { min: 1200, max: 2200 },  // Balanced (default)
  conservative: { min: 2500, max: 4000 }   // Slow but safe
};

const RETRY_PRESETS = {
  aggressive:   { unknownDate: 2, ownership: 2, action: 2 },
  normal:       { unknownDate: 3, ownership: 3, action: 3 },
  conservative: { unknownDate: 5, ownership: 5, action: 4 }
};

let MAX_UNKNOWN_DATE_RETRIES = RETRY_PRESETS.normal.unknownDate;
let MAX_OWNERSHIP_RETRIES = RETRY_PRESETS.normal.ownership;
let MAX_ACTION_RETRIES = RETRY_PRESETS.normal.action;
const RETRYABLE_ACTION_REASONS = new Set([
  "no-menu",
  "menu-empty",
  "card-not-found",
  "no-delete-item",
  "no-unretweet-btn",
  "no-undo-item",
  "menu-click-failed",
  "delete-click-failed",
  "confirm-click-failed",
  "delete-not-confirmed",
  "status-still-accessible",
  "unretweet-click-failed",
  "undo-click-failed",
  "unrepost-not-confirmed"
]);

function parseRetryOverride(value) {
  if (value === undefined || value === null || value === "") return null;
  const n = Number(value);
  if (!Number.isInteger(n) || n < 0) return null;
  return n;
}

function applyRetryPreset(speed, overrides = {}) {
  const preset = RETRY_PRESETS[speed] || RETRY_PRESETS.normal;
  MAX_UNKNOWN_DATE_RETRIES = preset.unknownDate;
  MAX_OWNERSHIP_RETRIES = preset.ownership;
  MAX_ACTION_RETRIES = preset.action;

  const unknownOverride = parseRetryOverride(overrides.unknownDate);
  if (unknownOverride !== null) MAX_UNKNOWN_DATE_RETRIES = unknownOverride;

  const ownershipOverride = parseRetryOverride(overrides.ownership);
  if (ownershipOverride !== null) MAX_OWNERSHIP_RETRIES = ownershipOverride;

  const actionOverride = parseRetryOverride(overrides.action);
  if (actionOverride !== null) MAX_ACTION_RETRIES = actionOverride;
}

// Config variables (set by runCleanup or CLI)
let PROFILE_HANDLE = null;
let INCLUDE_POSTS = true;
let INCLUDE_REPLIES = true;
let HANDLE_REPOSTS = false;
let TARGET = 10000;  // Default to large batch for "set and forget" usage
let HEADLESS = false;
let PRIVATE_MODE = false;  // Use fresh browser instead of Edge profile
let USE_FIREFOX = false;   // Use Firefox engine for anti-detection mode
let PROXY_SERVER = null;   // Optional proxy server (http://host:port)
let SPEED = "normal";
let MIN_DELAY_MS = 1200;
let MAX_DELAY_MS = 2200;
let LOGIN_WAIT_MS = 3 * 60 * 1000;
let STORAGE = path.resolve(__dirname, "x_auth_storage.json");
let MAX_SCROLL_PASSES = 100;  // Increased for large accounts (31K+ tweets)
let SCROLL_MIN_WAIT_MS = 200;
let SCROLL_MAX_WAIT_MS = 400;
let SCROLL_STEP_RATIO = 0.92;
let RETURN_TO_TOP = false;
let SLIDER_MODE = "delete";
let ROLLING_WINDOW = false;
let ROLLING_MONTHS = 3;
let DELETE_MONTH = 12;
let DELETE_YEAR = 2014;
let PROTECT_MONTH = new Date().getMonth() + 1;
let PROTECT_YEAR = new Date().getFullYear();
let DELETE_BEFORE = null;
let PROTECT_AFTER = null;

// Parse config from environment (CLI mode only)
function parseEnvConfig() {
  const now = new Date();
  // Support DMT_* env vars from Electron app, plus legacy names
  const rawHandle = process.env.DMT_HANDLE || process.env.PROFILE_HANDLE || process.argv[2] || savedConfig.handle;
  PROFILE_HANDLE = normalizeHandle(rawHandle);

  if (!PROFILE_HANDLE) {
    printHeader();

    const errorBox = boxen(
      chalk.red.bold('ERROR: Valid profile handle is required!\n\n') +
      chalk.white.bold('Usage:\n') +
      chalk.cyan('  node index.js ') + chalk.yellow('<your_handle>\n') +
      chalk.cyan('  PROFILE_HANDLE=') + chalk.yellow('handle') + chalk.cyan(' node index.js\n\n') +
      chalk.white('Handle rules: 1-15 characters, letters/numbers/underscore only\n\n') +
      chalk.white.bold('Example:\n') +
      chalk.gray('  node index.js johndoe\n') +
      chalk.gray('  TARGET=100 DELETE_YEAR_AND_OLDER=2020 node index.js johndoe'),
      {
        padding: 1,
        margin: 1,
        borderStyle: 'round',
        borderColor: 'red',
        title: '✗ Error',
        titleAlignment: 'center'
      }
    );
    console.log(errorBox);
    process.exit(1);
  }

  // Save handle for next time
  if (PROFILE_HANDLE !== savedConfig.handle) {
    saveConfig({ ...savedConfig, handle: PROFILE_HANDLE });
  }

  INCLUDE_POSTS = (process.env.DMT_POSTS ?? process.env.INCLUDE_POSTS ?? "true") === "true";
  INCLUDE_REPLIES = (process.env.DMT_REPLIES ?? process.env.INCLUDE_REPLIES ?? "true") === "true";
  HANDLE_REPOSTS = (process.env.DMT_REPOSTS ?? process.env.HANDLE_REPOSTS ?? "false") === "true";

  TARGET = parseInt(process.env.DMT_TARGET ?? process.env.TARGET ?? "10000", 10);
  HEADLESS = (process.env.DMT_HEADLESS ?? process.env.HEADLESS ?? "false") === "true";
  PRIVATE_MODE = (process.env.DMT_PRIVATE_MODE ?? process.env.PRIVATE_MODE ?? "false") === "true";
  USE_FIREFOX = (process.env.DMT_USE_FIREFOX ?? process.env.USE_FIREFOX ?? "false") === "true";
  PROXY_SERVER = normalizeProxy(process.env.DMT_PROXY ?? process.env.PROXY ?? "");
  SPEED = process.env.DMT_SPEED ?? process.env.SPEED ?? "normal";

  const delays = SPEED_PRESETS[SPEED] || SPEED_PRESETS.normal;
  MIN_DELAY_MS = parseInt(process.env.MIN_DELAY_MS ?? String(delays.min), 10);
  MAX_DELAY_MS = parseInt(process.env.MAX_DELAY_MS ?? String(delays.max), 10);
  applyRetryPreset(SPEED, {
    unknownDate: process.env.DMT_UNKNOWN_DATE_RETRIES ?? process.env.UNKNOWN_DATE_RETRIES,
    ownership: process.env.DMT_OWNERSHIP_RETRIES ?? process.env.OWNERSHIP_RETRIES,
    action: process.env.DMT_ACTION_RETRIES ?? process.env.ACTION_RETRIES
  });

  LOGIN_WAIT_MS = parseInt(process.env.LOGIN_WAIT_MS ?? String(3 * 60 * 1000), 10);
  STORAGE = path.resolve(__dirname, "x_auth_storage.json");

  MAX_SCROLL_PASSES = parseInt(process.env.MAX_SCROLL_PASSES ?? "5", 10);
  SCROLL_MIN_WAIT_MS = parseInt(process.env.SCROLL_MIN_WAIT_MS ?? "300", 10);
  SCROLL_MAX_WAIT_MS = parseInt(process.env.SCROLL_MAX_WAIT_MS ?? "600", 10);
  SCROLL_STEP_RATIO = parseFloat(process.env.SCROLL_STEP_RATIO ?? "0.92");
  RETURN_TO_TOP = (process.env.RETURN_TO_TOP ?? "false") === "true";

  DELETE_MONTH = parseInt(process.env.DMT_DELETE_MONTH ?? process.env.DELETE_MONTH ?? "12", 10);
  DELETE_YEAR = parseInt(process.env.DMT_DELETE_YEAR ?? process.env.DELETE_YEAR ?? process.env.DELETE_YEAR_AND_OLDER ?? "2014", 10);
  PROTECT_MONTH = parseInt(process.env.DMT_PROTECT_MONTH ?? process.env.PROTECT_MONTH ?? String(now.getMonth() + 1), 10);
  PROTECT_YEAR = parseInt(process.env.DMT_PROTECT_YEAR ?? process.env.PROTECT_YEAR ?? process.env.PROTECT_YEAR_AND_NEWER ?? String(now.getFullYear()), 10);
  SLIDER_MODE = normalizeSelectionMode(process.env.DMT_SLIDER_MODE ?? process.env.SLIDER_MODE ?? "delete");
  ROLLING_WINDOW = toBoolean(process.env.DMT_ROLLING_WINDOW ?? process.env.ROLLING_WINDOW ?? false);
  ROLLING_MONTHS = toPositiveInt(process.env.DMT_ROLLING_MONTHS ?? process.env.ROLLING_MONTHS ?? "3", 3);

  const bounds = resolveDateBounds({
    sliderMode: SLIDER_MODE,
    rollingWindow: ROLLING_WINDOW,
    rollingMonths: ROLLING_MONTHS,
    deleteMonth: DELETE_MONTH,
    deleteYear: DELETE_YEAR,
    protectMonth: PROTECT_MONTH,
    protectYear: PROTECT_YEAR,
    now
  });
  DELETE_BEFORE = bounds.deleteBefore;
  PROTECT_AFTER = bounds.protectAfter;
}


const RE_DELETE = /(Delete|Eliminar|Supprimer|Löschen|Elimina|Excluir|Удалить|削除|삭제|刪除)/i;
const RE_UNDO_REPOST = /(Undo\s+(Repost|Retweet)|Unretweet|Deshacer\s+Repost|Annuler\s+Retweet|zurücknehmen|Desfazer|Отменить|취소|转推)/i;

// ================= UTILITIES =================
function rand(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
async function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
async function pause(minMs, maxMs) { await sleep(rand(minMs, maxMs)); }

function getRetryEntry(retryState, key) {
  let entry = retryState.get(key);
  if (!entry) {
    entry = { unknownDate: 0, ownership: 0, action: 0 };
    retryState.set(key, entry);
  }
  return entry;
}

function normalizeProxy(rawProxy) {
  if (typeof rawProxy !== "string") return null;
  const trimmed = rawProxy.trim();
  if (!trimmed) return null;
  if (/^(http|https|socks4|socks5):\/\//i.test(trimmed)) return trimmed;
  if (/^[^:\s]+:\d{2,5}$/.test(trimmed)) return `http://${trimmed}`;
  return null;
}

function finalizeSeenKey(seen, retryState, key) {
  seen.add(key);
  retryState.delete(key);
}

function registerActionFailure(seen, retryState, key, reason, options = {}) {
  const { forceRetry = false, label = "action failure" } = options;
  if (!key) return false;

  const retryable = forceRetry || RETRYABLE_ACTION_REASONS.has(reason);
  if (!retryable) {
    finalizeSeenKey(seen, retryState, key);
    return false;
  }

  const retryEntry = getRetryEntry(retryState, key);
  if (retryEntry.action < MAX_ACTION_RETRIES) {
    retryEntry.action++;
    seen.delete(key);
    log("info", `Retrying ${label} (${reason}) (${retryEntry.action}/${MAX_ACTION_RETRIES})`);
    return true;
  }

  finalizeSeenKey(seen, retryState, key);
  return false;
}

async function pauseLikeHuman(page, removedCount, rhythmState) {
  await pause(MIN_DELAY_MS, MAX_DELAY_MS);

  if (removedCount > 0 && removedCount >= rhythmState.nextLongPauseAt) {
    const longPauseMs = rand(4500, 11000);
    log("info", `Natural pause (${(longPauseMs / 1000).toFixed(1)}s)`);
    await page.waitForTimeout(longPauseMs);
    rhythmState.nextLongPauseAt = removedCount + rand(28, 60);
    return;
  }

  // Occasional hesitation to avoid perfectly periodic timing.
  if (Math.random() < 0.14) {
    await page.waitForTimeout(rand(450, 1400));
  }
}

// Timeout wrapper to prevent hanging on video tweets
async function withTimeout(promise, ms = 3000, fallback = null) {
  return Promise.race([
    promise,
    new Promise(resolve => setTimeout(() => resolve(fallback), ms))
  ]);
}

// Kill all videos on page - pause, remove source, prevent loading
async function pauseAllVideos(page) {
  try {
    await page.evaluate(() => {
      document.querySelectorAll('video').forEach(v => {
        v.pause();
        v.currentTime = 0;
        v.preload = 'none';
        v.autoplay = false;
        v.src = '';  // Remove source to stop network requests
        v.load();    // Force reload with empty src
      });
      // Also kill any pending video network requests
      document.querySelectorAll('source').forEach(s => s.remove());
    });
  } catch {}
}

// Dismiss common X/Twitter popups that can block interactions
async function dismissPopups(page) {
  try {
    // Cookie consent - "Accept all cookies" or close button
    const cookieSelectors = [
      '[data-testid="BottomBar"] button:has-text("Accept")',
      'button:has-text("Accept all cookies")',
      'button:has-text("Accept cookies")',
      '[aria-label="Close"]'
    ];

    // Premium/subscription prompts
    const premiumSelectors = [
      '[data-testid="sheetDialog"] [aria-label="Close"]',
      '[role="dialog"] button[aria-label="Close"]',
      'button:has-text("Not now")',
      'button:has-text("Maybe later")'
    ];

    // Notification prompts
    const notificationSelectors = [
      'button:has-text("Not now")',
      '[data-testid="app-bar-close"]'
    ];

    // General modal close buttons
    const closeSelectors = [
      '[data-testid="app-bar-close"]',
      '[data-testid="xMigrationBottomBar"] button',
      '[role="dialog"] [aria-label="Close"]',
      'div[data-testid="confirmationSheetCancel"]'
    ];

    const allSelectors = [...cookieSelectors, ...premiumSelectors, ...notificationSelectors, ...closeSelectors];

    for (const selector of allSelectors) {
      try {
        const el = page.locator(selector).first();
        const count = await el.count().catch(() => 0);
        if (count > 0 && await el.isVisible().catch(() => false)) {
          await el.click({ timeout: 1000 }).catch(() => {});
          await page.waitForTimeout(300);
        }
      } catch {}
    }

    // Also try pressing Escape to close any modal
    await page.keyboard.press('Escape').catch(() => {});

  } catch {}
}

// ================= AUTH =================
async function isLoggedIn(context) {
  try { return (await context.cookies()).some(c => c.name.toLowerCase() === "auth_token"); }
  catch { return false; }
}

// Sign out of X/Twitter completely
async function signOut(page, context) {
  log("info", "Signing out of X...");
  try {
    // Clear all cookies first
    await context.clearCookies();

    // Navigate to logout page
    await page.goto('https://x.com/logout', { waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => {});
    await page.waitForTimeout(1500);

    // Click the logout confirmation button if present
    const confirmSelectors = [
      '[data-testid="confirmationSheetConfirm"]',
      'button:has-text("Log out")',
      '[role="button"]:has-text("Log out")'
    ];

    for (const selector of confirmSelectors) {
      const btn = page.locator(selector);
      const count = await btn.count().catch(() => 0);
      if (count > 0) {
        await btn.first().click({ timeout: 5000 }).catch(() => {});
        await page.waitForTimeout(2000);
        break;
      }
    }

    // Clear cookies again after logout
    await context.clearCookies();

    // Verify we're logged out
    const stillLoggedIn = await isLoggedIn(context);
    if (stillLoggedIn) {
      log("warn", "Cookies still present after logout - clearing again");
      await context.clearCookies();
    }

    log("success", "Signed out successfully");
    return true;
  } catch (err) {
    log("warn", `Sign out error: ${err?.message || err}`);
    // Still try to clear cookies
    await context.clearCookies().catch(() => {});
    return false;
  }
}

// Get the currently logged-in account handle from the sidebar
async function getLoggedInHandle(page) {
  try {
    // Look for the account switcher in the sidebar which shows current handle
    const accountSelectors = [
      '[data-testid="SideNav_AccountSwitcher_Button"] [dir="ltr"] span',  // Sidebar account button
      '[data-testid="AccountSwitcher"] span[dir="ltr"]',
      'nav [data-testid="AppTabBar_Profile_Link"]',  // Profile link in nav
      'a[href*="/"][data-testid="AppTabBar_Profile_Link"]'
    ];

    for (const selector of accountSelectors) {
      const el = page.locator(selector);
      const count = await el.count().catch(() => 0);
      if (count > 0) {
        const text = await el.first().innerText().catch(() => '');
        // Extract handle (starts with @)
        const match = text.match(/@(\w+)/);
        if (match) return match[1].toLowerCase();
      }
    }

    // Try to get from profile link href
    const profileLink = page.locator('[data-testid="AppTabBar_Profile_Link"]');
    const href = await profileLink.getAttribute('href').catch(() => null);
    if (href) {
      const match = href.match(/^\/(\w+)$/);
      if (match) return match[1].toLowerCase();
    }

    return null;
  } catch {
    return null;
  }
}

// Verify the logged-in account matches the expected handle
async function verifyAccount(page, expectedHandle) {
  try {
    // Check if we're on the right profile by looking at the URL or page content
    log("info", `Navigating to profile @${expectedHandle}...`);
    await page.goto(`https://x.com/${expectedHandle}`, { waitUntil: "domcontentloaded", timeout: 30000 });
    await page.waitForTimeout(3000); // Give page time to fully load

    // FIRST: Check who is actually logged in via sidebar
    const loggedInAs = await getLoggedInHandle(page);
    if (loggedInAs) {
      if (loggedInAs === expectedHandle.toLowerCase()) {
        log("success", `Confirmed logged in as @${loggedInAs}`);
      } else {
        log("error", `WRONG ACCOUNT! Logged in as @${loggedInAs}, but expected @${expectedHandle}`);
        return false;
      }
    }

    // Strategy 1: Look for "Edit profile" button (multiple possible selectors)
    const editSelectors = [
      '[data-testid="editProfileButton"]',           // Most reliable - data-testid
      'a[href="/settings/profile"]',                  // Direct link
      'button:has-text("Edit profile")',              // Button with text
      'a:has-text("Edit profile")',                   // Link with text
      '[aria-label="Edit profile"]'                   // Aria label
    ];

    for (const selector of editSelectors) {
      const el = page.locator(selector);
      const count = await el.count().catch(() => 0);
      if (count > 0) {
        log("success", `Found edit profile button (${selector})`);
        return true;
      }
    }

    // Strategy 2: Check if there's NO "Follow" button (means it's our profile)
    const followSelectors = [
      '[data-testid="followButton"]',
      'button:has-text("Follow")',
      '[aria-label*="Follow @"]'
    ];

    let hasFollowButton = false;
    for (const selector of followSelectors) {
      const el = page.locator(selector);
      const count = await el.count().catch(() => 0);
      if (count > 0) {
        const text = await el.first().innerText().catch(() => '');
        // "Following" is okay (we follow ourselves? no), but "Follow" means it's not our profile
        if (text === 'Follow') {
          log("warn", `Found Follow button - this is NOT our profile`);
          hasFollowButton = true;
          break;
        }
      }
    }

    if (hasFollowButton) {
      return false;
    }

    // Strategy 3: If we confirmed logged-in handle matches, trust that
    if (loggedInAs && loggedInAs === expectedHandle.toLowerCase()) {
      return true;
    }

    // Strategy 4: Check URL matches expected handle (case-insensitive) - ONLY if edit button found
    const currentUrl = page.url().toLowerCase();
    if (currentUrl.includes(`x.com/${expectedHandle.toLowerCase()}`)) {
      // Without Edit button AND without logged-in confirmation, this is NOT safe
      log("warn", `On profile URL but could not confirm account ownership`);
      log("warn", `Please ensure you are logged in as @${expectedHandle}`);
      return false;  // Changed from true - don't assume!
    }

    log("warn", `Could not verify profile ownership - URL: ${page.url()}`);
    return false;
  } catch (err) {
    log("error", `verifyAccount error: ${err?.message || err}`);
    return false;
  }
}

async function waitForLogin(page, context, spinner, storagePath) {
  const start = Date.now();
  while (Date.now() - start < LOGIN_WAIT_MS) {
    if (await isLoggedIn(context)) {
      try { await context.storageState({ path: storagePath }); } catch {}
      spinner.succeed(chalk.green('Session saved'));
      return true;
    }
    await page.waitForTimeout(1000);
  }
  return false;
}

async function ensureLoggedIn(page, context) {
  const storagePath = getStoragePath(PROFILE_HANDLE);

  // Navigate to X first to pick up any existing Edge session cookies
  log("info", "Checking X login status...");
  try {
    await page.goto('https://x.com/home', { waitUntil: "domcontentloaded", timeout: 30000 });
    await page.waitForTimeout(2000); // Let cookies settle
  } catch {
    // Might redirect to login if not authenticated - that's fine
  }

  // Now check if logged in (from Edge profile or saved session)
  if (await isLoggedIn(context)) {
    log("info", `Verifying account is @${PROFILE_HANDLE}...`);
    const isCorrectAccount = await verifyAccount(page, PROFILE_HANDLE);

    if (isCorrectAccount) {
      log("success", chalk.green(`Verified: logged in as @${PROFILE_HANDLE}`));
      // Save/update session file for this handle
      try { await context.storageState({ path: storagePath }); } catch {}
      return true;
    } else {
      // Logged in but wrong account - sign out and force re-login
      log("warn", chalk.yellow(`Logged in as wrong account! Need @${PROFILE_HANDLE}`));
      clearSession(PROFILE_HANDLE);

      // Use proper sign out
      await signOut(page, context);

      // Navigate to login page
      await page.goto('https://x.com/login', { waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => {});
    }
  } else {
    // Not logged in at all
    log("info", `Not logged in. Please log in as @${PROFILE_HANDLE}`);
  }

  const spinner = ora({
    text: chalk.yellow(`Please log in as @${PROFILE_HANDLE}...`),
    spinner: 'dots12'
  }).start();

  // Go to X login page
  await page.goto('https://x.com/login', { waitUntil: "domcontentloaded" }).catch(() => {});

  // Give it a moment to settle
  await page.waitForTimeout(2000);

  spinner.text = chalk.yellow(`Waiting for @${PROFILE_HANDLE} login (${Math.round(LOGIN_WAIT_MS / 1000)}s timeout)...`);

  const ok = await waitForLogin(page, context, spinner, storagePath);
  if (ok) {
    // Verify the account after login
    const isCorrect = await verifyAccount(page, PROFILE_HANDLE);
    if (!isCorrect) {
      spinner.fail(chalk.red(`Logged in as wrong account! Need @${PROFILE_HANDLE}`));
      clearSession(PROFILE_HANDLE);
      return false;
    }
    return true;
  }

  // In GUI mode, keep waiting for login (no stdin available)
  if (!IS_CLI) {
    spinner.text = chalk.yellow(`Waiting for login... Complete login in the browser window`);
    log("info", "Please log in to X/Twitter in the browser window that opened");

    // Extended wait for GUI mode - check every 2 seconds for up to 5 minutes
    const extendedWaitMs = 5 * 60 * 1000;
    const extendedStart = Date.now();
    while (Date.now() - extendedStart < extendedWaitMs) {
      if (await isLoggedIn(context)) {
        const isCorrect = await verifyAccount(page, PROFILE_HANDLE);
        if (isCorrect) {
          try { await context.storageState({ path: storagePath }); } catch {}
          spinner.succeed(chalk.green(`Logged in as @${PROFILE_HANDLE}`));
          log("success", `Successfully logged in as @${PROFILE_HANDLE}`);
          return true;
        } else {
          log("warn", `Logged in as wrong account! Need @${PROFILE_HANDLE}`);
          clearSession(PROFILE_HANDLE);
          // Keep waiting for correct account
        }
      }
      await page.waitForTimeout(2000);
    }

    spinner.fail(chalk.red('Login timeout'));
    log("error", "Login timeout - please try again");
    return false;
  }

  // CLI mode: wait for Enter key
  spinner.warn(chalk.yellow('Still waiting... Press Enter after logging in.'));
  await new Promise(res => { process.stdin.resume(); process.stdin.once("data", res); });

  // Give it a moment after pressing Enter
  await new Promise(r => setTimeout(r, 2000));

  if (await isLoggedIn(context)) {
    // Verify account after manual login
    const isCorrect = await verifyAccount(page, PROFILE_HANDLE);
    if (!isCorrect) {
      log("error", chalk.red(`Wrong account! Need @${PROFILE_HANDLE}`));
      clearSession(PROFILE_HANDLE);
      return false;
    }

    try {
      await context.storageState({ path: storagePath });
      log("success", chalk.green(`Session saved for @${PROFILE_HANDLE}`));
    } catch (e) {
      log("warn", `Could not save session: ${e.message}`);
    }
    return true;
  }

  log("warn", chalk.yellow('Login not detected'));
  return false;
}

// ================= NAVIGATION =================
async function gotoProfileTab(page, tab) {
  const url = tab === "Replies"
    ? `https://x.com/${PROFILE_HANDLE}/with_replies`
    : `https://x.com/${PROFILE_HANDLE}`;

  const spinner = ora({
    text: chalk.cyan(`Loading ${tab}...`),
    spinner: 'dots12'
  }).start();

  try {
    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 60000 });

    // Kill videos IMMEDIATELY to prevent network stalling
    await pauseAllVideos(page);

    await page.waitForSelector("main", { timeout: 30000 });

    const currentUrl = page.url();
    if (!currentUrl.includes(PROFILE_HANDLE)) {
      spinner.text = chalk.yellow('Retrying navigation...');
      await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
      await pauseAllVideos(page);
    }

    // Dismiss any popups that appeared (cookie banners, premium prompts, etc)
    await dismissPopups(page);

    spinner.succeed(chalk.green(`Loaded @${PROFILE_HANDLE}/${tab}`));
  } catch (err) {
    spinner.fail(chalk.red(`Navigation failed: ${err.message}`));
    throw err;
  }
}

function allCards(page) {
  return page.locator('article[data-testid="tweet"], article[role="article"]');
}

// ================= DATE EXTRACTION =================
async function dateFromLocator(locator, timeoutMs) {
  const count = await withTimeout(locator.count(), timeoutMs, 0);
  if (count === 0) return null;

  const datetime = await withTimeout(locator.getAttribute('datetime'), timeoutMs, null);
  if (!datetime) return null;

  const date = new Date(datetime);
  return isNaN(date.getTime()) ? null : date;
}

async function readTweetDate(card, timeoutMs) {
  const selectors = [
    '[data-testid="User-Name"] time[datetime]',
    'a[href*="/status/"] time[datetime]',
    'time[datetime]'
  ];

  for (const selector of selectors) {
    const date = await dateFromLocator(card.locator(selector).first(), timeoutMs);
    if (date) return date;
  }
  return null;
}

async function getTweetDate(card) {
  try {
    const firstPass = await readTweetDate(card, 2800);
    if (firstPass) return firstPass;

    // Retry once for partially rendered cards.
    await sleep(180);
    return readTweetDate(card, 3600);
  } catch {
    return null;
  }
}

function formatDate(date) {
  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
  return `${months[date.getMonth()]} ${date.getFullYear()}`;
}

async function getTweetPreview(card) {
  try {
    const tweetText = await withTimeout(
      card.locator('[data-testid="tweetText"]').first().innerText().catch(() => ""),
      2000, ""
    );
    let preview = (tweetText || "").substring(0, 40).replace(/\n/g, " ");
    if ((tweetText || "").length > 40) preview += "...";
    return preview;
  } catch {
    return "";
  }
}

async function shouldDeleteByDate(card) {
  const [tweetDate, preview] = await Promise.all([
    getTweetDate(card),
    getTweetPreview(card)
  ]);

  if (tweetDate === null) {
    return { decision: "unknown", dateStr: null, preview };
  }

  const dateStr = formatDate(tweetDate);

  if (tweetDate >= PROTECT_AFTER) {
    return { decision: "protect", dateStr, preview };
  }

  if (tweetDate >= DELETE_BEFORE) {
    return { decision: "delete", dateStr, preview };
  }

  return { decision: "too-old", dateStr, preview };
}

// ================= TWEET OPERATIONS =================

// Check if this card shows a repost by the current user
async function isUserRepost(card) {
  try {
    // Method 1: Check for unretweet button (green repost icon) - most reliable
    const repostBtn = card.locator('[data-testid="unretweet"]');
    const repostCount = await withTimeout(repostBtn.count(), 1500, 0);
    if (repostCount > 0) {
      console.log("[DEBUG] isUserRepost: found unretweet button in card");
      return true;
    }

    // Method 2: Check for social context (repost indicator at top of card)
    // Works across languages - any social context with repost icon suggests it's a repost
    const socialContext = card.locator('[data-testid="socialContext"]');
    const contextCount = await withTimeout(socialContext.count(), 1000, 0);
    if (contextCount > 0) {
      const contextText = await withTimeout(socialContext.first().innerText().catch(() => ""), 1000, "");
      // Check multiple language patterns
      const repostPatterns = [
        'repost', 'retweet', 'republish',  // English
        'repost', 'retuite',                // Spanish variants
        'reposté', 'retweeté', 'republié',  // French
        'retweetet', 'geteilt',             // German
        'リツイート', 'リポスト',             // Japanese
        '转推', '轉推'                       // Chinese
      ];
      const textLower = contextText.toLowerCase();
      if (repostPatterns.some(p => textLower.includes(p))) {
        console.log(`[DEBUG] isUserRepost: social context matches pattern: "${contextText}"`);
        return true;
      }
      // Also check if social context has user's profile link (indicates "You reposted")
      const userLink = socialContext.locator(`a[href="/${PROFILE_HANDLE}"]`);
      if (await withTimeout(userLink.count(), 500, 0) > 0) {
        console.log("[DEBUG] isUserRepost: social context has user's profile link");
        return true;
      }
    }

    // Method 3: Check for repost icon SVG (the rotating arrows icon when highlighted)
    const repostIcon = card.locator('[data-testid="unretweet"] svg, [data-testid="retweet"][style*="color"]');
    const iconCount = await withTimeout(repostIcon.count(), 500, 0);
    if (iconCount > 0) {
      console.log("[DEBUG] isUserRepost: found repost icon");
      return true;
    }

    return false;
  } catch (e) {
    console.log(`[DEBUG] isUserRepost error: ${e?.message || e}`);
    return false;
  }
}

async function isYours(page, card) {
  // Check if tweet author is the user
  const authorLink = await withTimeout(card.locator(`a[href="/${PROFILE_HANDLE}"]`).count(), 1500, 0);
  if (authorLink > 0) return { yours: true, transient: false, reason: "author-link", isRetweet: false };

  const userNameLink = await withTimeout(card.locator(`[data-testid="User-Name"] a[href="/${PROFILE_HANDLE}"]`).count(), 1500, 0);
  if (userNameLink > 0) return { yours: true, transient: false, reason: "username-link", isRetweet: false };

  // Check if this is a repost by the user (for undoing reposts)
  if (HANDLE_REPOSTS && await isUserRepost(card)) {
    return { yours: true, transient: false, reason: "user-repost", isRetweet: true };
  }

  // Last resort: check if menu has Delete option
  const menuCheck = await menuHasDelete(page, card);
  if (menuCheck.hasDelete) return { yours: true, transient: false, reason: "menu-delete", isRetweet: false };
  if (menuCheck.transient) return { yours: false, transient: true, reason: menuCheck.reason, isRetweet: false };
  return { yours: false, transient: false, reason: "not-yours", isRetweet: false };
}

// Scroll to top of page
async function scrollToTop(page) {
  await page.evaluate(() => window.scrollTo(0, 0));
  await page.waitForTimeout(300);
}

async function statusKey(card) {
  const h = await withTimeout(
    card.locator('a[href*="/status/"]').first().getAttribute("href").catch(() => null),
    2000, null
  );
  if (!h) return null;
  try { return new URL(h, "https://x.com").pathname; } catch { return h; }
}

async function openMenu(page, card) {
  // IMPORTANT: Only target "more actions" controls, never repost/like/reply buttons.
  // X occasionally changes this control across variants/locales.
  const more = card.locator([
    'button[data-testid="caret"]',
    'div[data-testid="caret"]',
    'button[aria-label="More"]',
    'div[aria-label="More"]',
    'button[aria-label="More actions"]',
    'button[aria-label="More options"]',
    'button[aria-label*="More"]',
    'div[aria-label*="More"]'
  ].join(", "));
  if (!(await more.count())) return false;
  try {
    await more.first().click({ delay: 10, timeout: 5000 });
  } catch {
    return false;
  }
  await page.waitForTimeout(220);
  return true;
}

function getMenuItemsLocator(page) {
  return page.locator([
    '[role="menu"]:visible div[role="menuitem"]',
    '[role="menu"]:visible a[role="menuitem"]',
    '[role="menu"]:visible button[role="menuitem"]'
  ].join(", "));
}

function statusIdFromKey(key) {
  if (typeof key !== "string") return null;
  const m = key.match(/\/status\/(\d+)/);
  return m ? m[1] : null;
}

function cardByStatusId(page, statusId) {
  if (!statusId) return null;
  return allCards(page)
    .filter({ has: page.locator(`a[href*="/status/${statusId}"]`) })
    .first();
}

async function waitForActionApplied(page, statusId, timeoutMs = 7000) {
  if (!statusId) return false;
  const deadline = Date.now() + timeoutMs;

  while (Date.now() < deadline) {
    const targetCard = cardByStatusId(page, statusId);
    const count = await withTimeout(targetCard.count(), 1000, 0);
    if (count === 0) return true;
    await page.waitForTimeout(250);
  }

  return false;
}

async function verifyDeletedViaStatusRequest(context, statusId) {
  if (!context || !statusId) return { ok: false, reason: "status-check-error" };
  const statusPath = `/status/${statusId}`;
  const statusUrl = `https://x.com/i/web${statusPath}`;

  try {
    const response = await context.request.get(statusUrl, {
      timeout: 10000,
      failOnStatusCode: false
    });

    const httpStatus = response.status();
    if (httpStatus >= 400) {
      return { ok: true, reason: `http-${httpStatus}` };
    }

    const finalUrl = (response.url() || "").toLowerCase();
    if (finalUrl && !finalUrl.includes(statusPath)) {
      return { ok: true, reason: `redirected-${httpStatus}` };
    }

    const body = (await response.text()).toLowerCase();
    const deletedMarkers = [
      "this post was deleted",
      "this post is unavailable",
      "this page doesn't exist",
      "this page doesn’t exist",
      "post unavailable"
    ];
    if (deletedMarkers.some(marker => body.includes(marker))) {
      return { ok: true, reason: "body-marker" };
    }

    if (body.includes(statusPath)) {
      return { ok: false, reason: "status-still-accessible" };
    }

    return { ok: false, reason: "status-check-uncertain" };
  } catch {
    return { ok: false, reason: "status-check-error" };
  }
}

async function menuHasDelete(page, card) {
  if (!(await openMenu(page, card))) {
    return { hasDelete: false, transient: true, reason: "no-menu" };
  }
  const items = getMenuItemsLocator(page);
  const n = await withTimeout(items.count(), 3000, 0);
  if (n === 0) {
    await page.keyboard.press("Escape").catch(() => {});
    return { hasDelete: false, transient: true, reason: "menu-empty" };
  }
  let has = false;
  for (let i = 0; i < n && i < 10; i++) { // Limit loop iterations
    const t = ((await withTimeout(items.nth(i).innerText().catch(() => ""), 1000, "")) || "").trim();
    if (RE_DELETE.test(t)) { has = true; break; }
  }
  await page.keyboard.press("Escape").catch(() => {});
  if (has) return { hasDelete: true, transient: false, reason: "delete-item-found" };
  return { hasDelete: false, transient: false, reason: "no-delete-item" };
}

async function confirmDeleteIfNeeded(page) {
  const btn = page.locator([
    'div[data-testid="confirmationSheetConfirm"]',
    'button[data-testid="confirmationSheetConfirm"]',
    'button:has-text("Delete")',
    'div[role="button"]:has-text("Delete")'
  ].join(", ")).first();
  const count = await withTimeout(btn.count(), 2000, 0);
  if (count === 0) return { ok: true, reason: "no-confirm-needed" };
  try {
    await btn.click({ delay: 10, timeout: 5000 });
    return { ok: true, reason: "confirmed" };
  } catch {
    return { ok: false, reason: "confirm-click-failed" };
  }
}

async function tryDelete(page, card, key, statusId = statusIdFromKey(key)) {
  if (!(await openMenu(page, card))) return { ok: false, reason: "no-menu" };

  // Try to find and click Delete
  const items = getMenuItemsLocator(page);
  const n = await withTimeout(items.count(), 2000, 0);

  if (n === 0) {
    await page.keyboard.press("Escape").catch(() => {});
    return { ok: false, reason: "menu-empty" };
  }

  // Look for Delete option
  for (let i = 0; i < n && i < 10; i++) {
    const t = ((await withTimeout(items.nth(i).innerText().catch(() => ""), 1000, "")) || "").trim();
    if (RE_DELETE.test(t)) {
      try {
        await items.nth(i).click({ delay: 10, timeout: 5000 });
      } catch {
        return { ok: false, reason: "delete-click-failed" };
      }
      await page.waitForTimeout(150);
      const confirm = await confirmDeleteIfNeeded(page);
      if (!confirm.ok) return { ok: false, reason: confirm.reason };
      const applied = await waitForActionApplied(page, statusId);
      if (!applied) return { ok: false, reason: "delete-not-confirmed" };
      const postCheck = await verifyDeletedViaStatusRequest(page.context(), statusId);
      if (!postCheck.ok && postCheck.reason === "status-still-accessible") {
        return { ok: false, reason: postCheck.reason };
      }
      if (!postCheck.ok) {
        log("warn", `Post-delete check inconclusive (${postCheck.reason}); accepting DOM confirmation`);
      }
      return { ok: true, reason: "deleted" };
    }
  }

  // Delete not found - log what WAS in the menu for debugging
  const menuItems = [];
  for (let i = 0; i < Math.min(n, 5); i++) {
    const t = ((await withTimeout(items.nth(i).innerText().catch(() => ""), 500, "")) || "").trim();
    if (t) menuItems.push(t.split('\n')[0]); // First line only
  }
  await page.keyboard.press("Escape").catch(() => {});
  console.log(`[DEBUG] Menu had ${n} items: ${menuItems.join(', ')}`);

  return { ok: false, reason: "no-delete-item" };
}

async function tryUndoRepost(page, card, key, statusId = statusIdFromKey(key)) {
  if (!HANDLE_REPOSTS) return { ok: false, reason: "repost-disabled" };

  // Find the repost/unretweet button - green when active
  // First try within card scope, then try page-level for retweets where button may be outside card
  let unretweetBtn = card.locator('[data-testid="unretweet"]').first();
  let retweetBtn = card.locator('[data-testid="retweet"]').first();

  // Check for the unretweet button (indicates this is a repost)
  let unretweetCount = await withTimeout(unretweetBtn.count(), 2000, 0);

  // If not found in card, the card might be the inner tweet - try page level
  // Look for unretweet button that's visible (in viewport)
  if (unretweetCount === 0) {
    const pageUnretweet = page.locator('[data-testid="unretweet"]:visible').first();
    const pageUnretweetCount = await withTimeout(pageUnretweet.count(), 1000, 0);
    if (pageUnretweetCount > 0) {
      log("info", "Found unretweet button at page level (retweet card)");
      unretweetBtn = pageUnretweet;
      unretweetCount = 1;
    }
  }

  if (unretweetCount > 0) {
    // Found unretweet button - click it to undo
    log("info", "Found unretweet button, attempting undo...");
    try {
      await unretweetBtn.click({ timeout: 5000 });
    } catch {
      return { ok: false, reason: "unretweet-click-failed" };
    }
    await page.waitForTimeout(500);  // Wait longer for popup to appear

    // Try multiple selectors for the repost popup menu items
    // X's repost popup uses different selectors than the caret menu
    const popupSelectors = [
      'div[role="menuitem"]',
      'a[role="menuitem"]',
      'button[role="menuitem"]',
      '[data-testid="unretweetConfirm"]',  // Direct undo repost button
      'div[role="menu"] div[role="menuitem"]',
      '[role="menu"] span'
    ];

    for (const selector of popupSelectors) {
      const items = page.locator(selector);
      const n = await withTimeout(items.count(), 1000, 0);
      for (let i = 0; i < n && i < 5; i++) {
        const t = ((await withTimeout(items.nth(i).innerText().catch(() => ""), 500, "")) || "").trim();
        if (RE_UNDO_REPOST.test(t)) {
          log("info", `Clicking "${t}" to undo repost...`);
          try {
            await items.nth(i).click({ delay: 10, timeout: 5000 });
          } catch {
            return { ok: false, reason: "undo-click-failed" };
          }
          await page.waitForTimeout(300);
          const applied = await waitForActionApplied(page, statusId);
          if (!applied) return { ok: false, reason: "unrepost-not-confirmed" };
          return { ok: true, reason: "unreposted" };
        }
      }
    }

    // Also try clicking directly if there's an unretweetConfirm button
    const confirmBtn = page.locator('[data-testid="unretweetConfirm"]').first();
    const confirmCount = await withTimeout(confirmBtn.count(), 500, 0);
    if (confirmCount > 0) {
      try {
        await confirmBtn.click({ timeout: 3000 });
      } catch {
        return { ok: false, reason: "undo-click-failed" };
      }
      const applied = await waitForActionApplied(page, statusId);
      if (!applied) return { ok: false, reason: "unrepost-not-confirmed" };
      return { ok: true, reason: "unreposted" };
    }

    await page.keyboard.press("Escape").catch(() => {});
    return { ok: false, reason: "no-undo-item" };
  }

  // Check if there's a regular retweet button (not reposted)
  const retweetCount = await withTimeout(retweetBtn.count(), 2000, 0);
  if (retweetCount > 0) {
    // Has retweet button but NOT unretweet - this isn't our repost
    return { ok: false, reason: "not-a-repost" };
  }

  // Neither button found - might be a different tweet type
  return { ok: false, reason: "no-repost-btn" };
}

async function collectWorklist(page, want, seen, retryState, seenEver) {
  const cards = allCards(page);
  const n = await cards.count();
  const mine = [];
  for (let i = 0; i < n && mine.length < want; i++) {
    const card = cards.nth(i);
    const key = await statusKey(card);
    if (!key || seen.has(key)) continue;
    seenEver.add(key);
    const retryEntry = getRetryEntry(retryState, key);

    // Check date first to avoid menu interactions on protected/old tweets.
    const dateCheck = await shouldDeleteByDate(card);
    if (dateCheck.decision === "unknown") {
      if (retryEntry.unknownDate < MAX_UNKNOWN_DATE_RETRIES) {
        retryEntry.unknownDate++;
        log("info", `Date not ready, retrying (${retryEntry.unknownDate}/${MAX_UNKNOWN_DATE_RETRIES})`, `"${dateCheck.preview}"`);
        continue;
      }
      log("warn", `Unknown date, skipping`, `"${dateCheck.preview}"`);
      finalizeSeenKey(seen, retryState, key);
      emitEvent("skipped", { delta: 1, reason: "unknown-date" });
      continue;
    }

    retryEntry.unknownDate = 0;
    if (dateCheck.decision === "protect") {
      log("protect", chalk.green(`${dateCheck.dateStr} Protected`), chalk.gray(`"${dateCheck.preview}"`));
      finalizeSeenKey(seen, retryState, key);
      emitEvent("protected", { delta: 1 });
      continue;
    }
    if (dateCheck.decision === "too-old") {
      log("skip", chalk.gray(`${dateCheck.dateStr} Too old, kept`), chalk.gray(`"${dateCheck.preview}"`));
      finalizeSeenKey(seen, retryState, key);
      emitEvent("skipped", { delta: 1, reason: "too-old" });
      continue;
    }

    log("info", `${dateCheck.dateStr} in range (candidate)`, chalk.gray(`"${dateCheck.preview}"`));

    const ownership = await isYours(page, card);
    if (!ownership.yours) {
      if (ownership.transient && retryEntry.ownership < MAX_OWNERSHIP_RETRIES) {
        retryEntry.ownership++;
        log("info", `Ownership check pending (${ownership.reason}), retrying (${retryEntry.ownership}/${MAX_OWNERSHIP_RETRIES})`);
        continue;
      }
      if (ownership.transient) {
        log("info", `Ownership unresolved after retries (${ownership.reason}), skipping`);
      }
      finalizeSeenKey(seen, retryState, key);
      emitEvent("skipped", { delta: 1, reason: ownership.reason || "not-yours" });
      continue;
    }

    retryEntry.ownership = 0;
    // Preserve repost signal from ownership check; only re-check if still unknown.
    const isRetweet = ownership.isRetweet || (HANDLE_REPOSTS && await isUserRepost(card));
    seen.add(key); // Mark as in-flight; will be unmarked on retryable action failures.
    const statusId = statusIdFromKey(key);
    if (!statusId) {
      finalizeSeenKey(seen, retryState, key);
      emitEvent("skipped", { delta: 1, reason: "missing-status-id" });
      continue;
    }
    mine.push({ key, statusId, isRetweet });
  }
  return mine;
}

// ================= MAIN PROCESSING =================
async function processTab(page, tabName, removed, startTime) {
  console.log("");
  log("tab", chalk.magenta.bold(`Processing ${tabName}`));
  log("info", describeDateBounds({
    sliderMode: SLIDER_MODE,
    rollingWindow: ROLLING_WINDOW,
    rollingMonths: ROLLING_MONTHS,
    deleteMonth: DELETE_MONTH,
    deleteYear: DELETE_YEAR,
    protectMonth: PROTECT_MONTH,
    protectYear: PROTECT_YEAR
  }));

  await gotoProfileTab(page, tabName);

  let lastProgressTime = Date.now();
  let sweepCount = 0;
  const MAX_SWEEPS = 50;  // Max full sweeps before giving up
  const globalSeen = new Set();  // Track ALL tweets seen across entire session
  const seenEver = new Set();  // Monotonic scan count for loop detection/logging
  const retryState = new Map();  // Retry budgets for transient detection/action failures
  const rhythmState = { nextLongPauseAt: removed.count + rand(28, 60) };
  let loopDetectCount = 0;  // Count consecutive loops without progress

  // Outer loop: Full sweeps from top to bottom
  while (removed.count < TARGET && !isAborted() && sweepCount < MAX_SWEEPS) {
    sweepCount++;
    let deletedThisSweep = 0;
    let noLoadCount = 0;
    const seenBeforeSweep = seenEver.size;  // Track monotonic scan growth

    // Go to top for each sweep
    log("info", `Starting sweep ${sweepCount}...`);
    await scrollToTop(page);
    await page.waitForTimeout(1000);

    // Inner loop: Scroll down page by page, deleting as we go
    while (removed.count < TARGET && !isAborted() && noLoadCount < 10) {
      // Periodic status update
      if (Date.now() - lastProgressTime > 2 * 60 * 1000) {
        log("info", `Still running... ${removed.count}/${TARGET} deleted (sweep ${sweepCount})`);
        lastProgressTime = Date.now();
      }

      // Find deletable tweets in current view
      const work = await collectWorklist(page, Math.min(10, TARGET - removed.count), globalSeen, retryState, seenEver);

      // Debug: show what we found
      const totalCards = await allCards(page).count();
      log("info", `Found ${work.length} deletable of ${totalCards} total cards (${seenEver.size} scanned)`);

      // Pause videos and dismiss popups to prevent blocking
      await pauseAllVideos(page);
      await dismissPopups(page);

      if (work.length > 0) {
        noLoadCount = 0;

        // Delete each tweet found
        for (const workItem of work) {
          if (isAborted() || removed.count >= TARGET) break;

          // Extract identifiers and pre-computed repost signal from worklist
          const key = workItem.key;
          const statusId = workItem.statusId;
          const card = cardByStatusId(page, statusId);
          const isRetweet = workItem.isRetweet;

          const cardCount = await withTimeout(card.count(), 1200, 0);
          if (cardCount === 0) {
            log("info", "Card moved before action, retrying...");
            const willRetry = registerActionFailure(globalSeen, retryState, key, "card-not-found");
            if (!willRetry) emitEvent("skipped", { delta: 1, reason: "card-not-found" });
            continue;
          }

          try {
            // Kill any videos BEFORE scrolling to prevent network stalling
            await pauseAllVideos(page);

            // Timeout scroll to prevent hanging on video tweets
            await Promise.race([
              card.scrollIntoViewIfNeeded(),
              new Promise((_, reject) => setTimeout(() => reject(new Error('scroll timeout')), 3000))
            ]).catch(() => {});

            // Kill videos again after scroll (new ones may have loaded)
            await pauseAllVideos(page);
            await page.waitForTimeout(100);

            // Use pre-computed isRetweet from worklist (detected when card was fresh)
            // Retweets don't have "Delete" in caret menu, they need unretweet button
            let res;
            let deleteRes = { ok: false, reason: "not-tried" };
            let repostRes = { ok: false, reason: "not-tried" };

            if (isRetweet && HANDLE_REPOSTS) {
              // Retweet: try unretweet first, then delete as fallback
              log("info", "Detected as retweet - trying unretweet first");
              repostRes = await tryUndoRepost(page, card, key, statusId);
              res = repostRes;
              if (!repostRes.ok) {
                deleteRes = await tryDelete(page, card, key, statusId);
                res = deleteRes;
              }
            } else {
              // Regular tweet: try delete first, then unretweet as fallback
              deleteRes = await tryDelete(page, card, key, statusId);
              res = deleteRes;
              if (!deleteRes.ok && HANDLE_REPOSTS) {
                repostRes = await tryUndoRepost(page, card, key, statusId);
                res = repostRes;
              }
            }

            // Log if tweet couldn't be deleted - show both reasons
            if (!res.ok) {
              if (deleteRes.reason !== "not-tried" && repostRes.reason !== "not-tried" && deleteRes.reason !== repostRes.reason) {
                log("warn", `Skipped: delete failed (${deleteRes.reason}), repost failed (${repostRes.reason})`);
              } else if (deleteRes.reason !== "not-tried") {
                log("info", `Skipped: ${deleteRes.reason}`);
              } else {
                log("info", `Skipped: ${repostRes.reason}`);
              }

              const reasons = [res.reason, deleteRes.reason, repostRes.reason]
                .filter(reason => reason && reason !== "not-tried");
              const retryableReason = reasons.find(reason => RETRYABLE_ACTION_REASONS.has(reason));
              if (retryableReason) {
                const willRetry = registerActionFailure(globalSeen, retryState, key, retryableReason);
                if (!willRetry) emitEvent("skipped", { delta: 1, reason: retryableReason });
              } else if (key) {
                finalizeSeenKey(globalSeen, retryState, key);
                emitEvent("skipped", { delta: 1, reason: res.reason || "action-failed" });
              }
            }

            if (res.ok) {
              removed.count++;
              deletedThisSweep++;
              log("delete", `Deleted confirmed (${res.reason})`, key);
              emitEvent("deleted", { count: removed.count });
              updateProgress(removed.count, tabName, TARGET);
              lastProgressTime = Date.now();
              if (key) retryState.delete(key);
            }
          } catch (e) {
            log("error", "Delete failed (continuing)", e?.message || e);
            const willRetry = registerActionFailure(globalSeen, retryState, key, "exception", {
              forceRetry: true,
              label: "after exception"
            });
            if (!willRetry) emitEvent("skipped", { delta: 1, reason: "exception" });
          }

          await pauseLikeHuman(page, removed.count, rhythmState);
        }

        // Rate limit protection
        if (removed.count % 100 === 0 && removed.count > 0) {
          log("info", `${removed.count} deleted. Brief pause...`);
          await page.waitForTimeout(3000);
        }
      }

      // Scroll down to load more tweets - use multiple methods for reliability
      const beforeCount = await allCards(page).count();

      // Method 1: Scroll via keyboard (most reliable for infinite scroll)
      await page.keyboard.press('End');
      await page.waitForTimeout(500);
      await page.keyboard.press('PageDown');
      await page.waitForTimeout(500);
      await page.keyboard.press('PageDown');
      await page.waitForTimeout(1000);

      const afterCount = await allCards(page).count();
      console.log(`[SCROLL] ${beforeCount} → ${afterCount} cards loaded`);

      // Pause videos and dismiss any popups that appeared
      await pauseAllVideos(page);
      await dismissPopups(page);

      // Check if we hit the bottom (no new tweets loading)
      if (afterCount <= beforeCount) {
        noLoadCount++;
        console.log(`[SCROLL] No new content (attempt ${noLoadCount}/10)`);
      } else {
        noLoadCount = 0;
      }
    }

    const newTweetsSeen = seenEver.size - seenBeforeSweep;
    log("info", `Sweep ${sweepCount} complete: ${deletedThisSweep} deleted, ${newTweetsSeen} new tweets scanned (${seenEver.size} total)`);

    // Detect timeline looping - if no new tweets AND no deletions, timeline may have reset
    if (newTweetsSeen === 0 && deletedThisSweep === 0) {
      loopDetectCount++;
      log("warn", `Timeline may be looping (${loopDetectCount}/3 consecutive empty sweeps)`);

      if (loopDetectCount >= 3) {
        log("info", "Timeline appears to be looping with no new content. Done with tab.");
        break;
      }

      // Try refreshing page to break out of loop
      log("info", "Refreshing page to attempt breaking out of loop...");
      await page.reload({ waitUntil: "domcontentloaded", timeout: 30000 }).catch(() => {});
      await page.waitForTimeout(3000);
    } else if (deletedThisSweep === 0 && newTweetsSeen > 0) {
      // We're seeing new tweets but none are deletable - keep going
      loopDetectCount = 0;
      log("info", "New tweets found but none deletable in range. Continuing...");
    } else {
      // Made progress - reset loop counter
      loopDetectCount = 0;

      // If no deletions this sweep but we saw new tweets, might be done
      if (deletedThisSweep === 0) {
        log("info", "No more deletable tweets found. Done with tab.");
        break;
      }
    }
  }
}

async function run() {
  const startTime = Date.now();

  printHeader();
  printConfig({
    handle: PROFILE_HANDLE,
    target: TARGET,
    sliderMode: SLIDER_MODE,
    rollingWindow: ROLLING_WINDOW,
    rollingMonths: ROLLING_MONTHS,
    deleteMonth: DELETE_MONTH,
    deleteYear: DELETE_YEAR,
    protectMonth: PROTECT_MONTH,
    protectYear: PROTECT_YEAR,
    posts: INCLUDE_POSTS,
    replies: INCLUDE_REPLIES,
    reposts: HANDLE_REPOSTS,
    speed: SPEED
  });

  const launchSpinner = ora({
    text: chalk.cyan(USE_FIREFOX ? 'Launching Firefox...' : 'Checking for browser...'),
    spinner: 'dots12'
  }).start();

  let context, browser, page;

  // Browser args to prevent throttling when window loses focus
  const browserArgs = [
    "--disable-blink-features=AutomationControlled",
    "--disable-infobars",
    "--disable-automation",
    "--disable-backgrounding-occluded-windows",
    "--disable-renderer-backgrounding",
    "--disable-background-timer-throttling",
    "--autoplay-policy=user-gesture-required",  // Prevent video autoplay causing hangs
    "--test-type",  // Suppress "unsupported command-line flag" warnings
    "--no-sandbox"  // Required for some environments
  ];

  const handleStorage = getStoragePath(PROFILE_HANDLE);
  const useStorage = isSessionValid(PROFILE_HANDLE) ? handleStorage : undefined;
  const launchProxy = PROXY_SERVER ? { server: PROXY_SERVER } : undefined;

  const launchChromium = async () => {
    // Check for supported browser (Edge or Chrome)
    BROWSER_CHANNEL = getBrowserChannel();
    if (!BROWSER_CHANNEL) {
      log("error", "No supported Chromium browser found.");
      log("info", "Install Microsoft Edge or Google Chrome, or disable Firefox mode.");
      throw new Error("No supported browser found (Edge/Chrome unavailable)");
    }
    launchSpinner.text = chalk.cyan(`Launching ${BROWSER_CHANNEL === 'msedge' ? 'Edge' : 'Chrome'}...`);

    // Private mode: always use fresh browser (no Edge profile)
    if (PRIVATE_MODE) {
      log("info", "Using private browser mode (fresh session)");
      browser = await chromium.launch({
        headless: HEADLESS,
        channel: BROWSER_CHANNEL,
        proxy: launchProxy,
        args: browserArgs,
        ignoreDefaultArgs: ["--enable-automation"]
      });
      context = await browser.newContext({
        storageState: useStorage
      });
      page = await context.newPage();
      return;
    }

    if (BROWSER_CHANNEL === 'msedge') {
      // Try to use Edge profile (has extensions like 1Password)
      const userDataDir = process.env.EDGE_USER_DATA || path.join(process.env.LOCALAPPDATA || '', 'Microsoft', 'Edge', 'User Data');
      const profileDir = process.env.EDGE_PROFILE || 'Default';

      try {
        context = await chromium.launchPersistentContext(
          path.join(userDataDir, profileDir),
          {
            headless: HEADLESS,
            channel: BROWSER_CHANNEL,
            proxy: launchProxy,
            args: [
              ...browserArgs,
              "--no-first-run",
              "--no-default-browser-check",
              "--enable-extensions",
              "--disable-component-extensions-with-background-pages=false"
            ],
            ignoreDefaultArgs: ["--disable-extensions", "--enable-automation"]
          }
        );
        page = context.pages()[0] || await context.newPage();
        log("success", "Using your Edge profile with extensions");
        return;
      } catch (err) {
        // Fallback: Edge might be open, use fresh profile instead
        log("warn", "Edge may be open. Using fresh browser (close Edge for full access)");
        browser = await chromium.launch({
          headless: HEADLESS,
          channel: BROWSER_CHANNEL,
          proxy: launchProxy,
          args: browserArgs,
          ignoreDefaultArgs: ["--enable-automation"]
        });
        context = await browser.newContext({
          storageState: useStorage
        });
        page = await context.newPage();
        return;
      }
    }

    // Chrome doesn't support profile mode the same way, use fresh browser
    log("info", "Using Chrome (fresh session)");
    browser = await chromium.launch({
      headless: HEADLESS,
      channel: BROWSER_CHANNEL,
      proxy: launchProxy,
      args: browserArgs,
      ignoreDefaultArgs: ["--enable-automation"]
    });
    context = await browser.newContext({
      storageState: useStorage
    });
    page = await context.newPage();
  };

  if (USE_FIREFOX) {
    launchSpinner.text = chalk.cyan("Launching Firefox...");
    try {
      // Vary viewport a bit to avoid perfectly identical sessions.
      const viewport = {
        width: rand(1180, 1520),
        height: rand(780, 980)
      };

      if (PRIVATE_MODE) {
        browser = await firefox.launch({
          headless: HEADLESS,
          proxy: launchProxy
        });
        context = await browser.newContext({
          storageState: useStorage,
          viewport
        });
        page = await context.newPage();
        log("info", `Using Firefox private mode (${viewport.width}x${viewport.height})`);
      } else {
        const firefoxProfileDir = path.join(
          process.env.ELECTRON_USER_DATA || __dirname,
          "firefox-profile",
          PROFILE_HANDLE || "default"
        );
        try {
          context = await firefox.launchPersistentContext(firefoxProfileDir, {
            headless: HEADLESS,
            proxy: launchProxy,
            storageState: useStorage,
            viewport
          });
          page = context.pages()[0] || await context.newPage();
          log("info", `Using Firefox profile mode (${viewport.width}x${viewport.height})`);
        } catch (profileErr) {
          log("warn", `Firefox profile mode unavailable, using fresh Firefox session: ${profileErr?.message || profileErr}`);
          browser = await firefox.launch({
            headless: HEADLESS,
            proxy: launchProxy
          });
          context = await browser.newContext({
            storageState: useStorage,
            viewport
          });
          page = await context.newPage();
          log("info", `Using Firefox fresh mode (${viewport.width}x${viewport.height})`);
        }
      }
    } catch (err) {
      log("warn", `Firefox launch failed, falling back to Chromium: ${err?.message || err}`);
      await launchChromium();
    }
  } else {
    await launchChromium();
  }

  launchSpinner.succeed(chalk.green('Browser ready'));

  const loggedIn = await ensureLoggedIn(page, context);
  if (!loggedIn) {
    log("error", "Login required! Cannot proceed without authentication.");
    if (browser) await browser.close();
    else await context.close();
    throw new Error("Login required - please log in to X/Twitter first");
  }

  const tabs = [];
  // Process Replies FIRST - old tweets are usually on /with_replies page
  if (INCLUDE_REPLIES) tabs.push("Replies");
  if (INCLUDE_POSTS) tabs.push("Posts");
  if (tabs.length === 0 && HANDLE_REPOSTS) {
    // Reposts live on the profile timeline; use Posts tab when repost-only mode is selected.
    tabs.push("Posts");
    log("info", "Reposts-only mode: scanning profile timeline for reposts");
  }

  if (tabs.length === 0) {
    log("warn", chalk.yellow("Nothing to do - both Posts and Replies are disabled"));
    if (browser) await browser.close();
    else await context.close();
    return;
  }

  const removed = { count: 0 };

  // Create progress bar
  console.log("");
  createProgressBar(TARGET);

  for (const tab of tabs) {
    if (removed.count >= TARGET) break;
    await processTab(page, tab, removed, startTime);
  }

  stopProgress();

  // Save session for this specific handle
  try { await context.storageState({ path: getStoragePath(PROFILE_HANDLE) }); } catch {}
  if (browser) await browser.close();
  else await context.close();

  printSummary(removed.count, TARGET, startTime);

  if (removed.count >= TARGET) {
    console.log(chalk.green.bold('  🎉 Target reached! All done.\n'));
  } else {
    console.log(chalk.cyan('  ℹ Finished - no more matching tweets found\n'));
  }

  // Return actual deleted count for programmatic use
  return removed.count;
}

// Wait for keypress before exiting
async function waitForExit(message = 'Press Enter to exit...') {
  if (!IS_CLI) return;
  console.log(chalk.gray(`  ${message}`));
  process.stdin.resume();
  await new Promise(res => process.stdin.once('data', res));
}

/**
 * Run cleanup with config object (for Electron/programmatic use)
 * @param {Object} config - Configuration object
 * @param {string} config.handle - X/Twitter handle (without @)
 * @param {number} config.target - Maximum tweets to delete
 * @param {number} config.deleteMonth - Delete tweets before this month (1-12)
 * @param {number} config.deleteYear - Delete tweets before this year
 * @param {number} config.protectMonth - Protect tweets after this month (1-12)
 * @param {number} config.protectYear - Protect tweets after this year
 * @param {boolean} config.posts - Include regular posts
 * @param {boolean} config.replies - Include replies
 * @param {boolean} config.reposts - Include reposts/retweets
 * @param {string} config.speed - Speed preset: 'aggressive', 'normal', 'conservative'
 * @param {boolean} config.headless - Run browser in headless mode
 * @param {Object} callbacks - Callback functions
 * @param {Function} callbacks.onProgress - Progress callback: ({current, total, tab}) => void
 * @param {Function} callbacks.onLog - Log callback: ({type, message}) => void
 * @param {Function} callbacks.onComplete - Complete callback: ({deleted, target, elapsed}) => void
 */
async function runCleanup(config, callbacks = {}) {
  const now = new Date();
  // Set callbacks
  onProgressCallback = callbacks.onProgress || null;
  onLogCallback = callbacks.onLog || null;

  // Set config variables from passed config
  PROFILE_HANDLE = normalizeHandle(config.handle);
  if (!PROFILE_HANDLE) {
    throw new Error('Invalid X handle. Use 1-15 letters, numbers, or underscores.');
  }
  TARGET = config.target || 10000;
  DELETE_MONTH = config.deleteMonth || 12;
  DELETE_YEAR = config.deleteYear || 2014;
  PROTECT_MONTH = config.protectMonth || (now.getMonth() + 1);
  PROTECT_YEAR = config.protectYear || now.getFullYear();
  INCLUDE_POSTS = config.posts !== false;
  INCLUDE_REPLIES = config.replies !== false;
  HANDLE_REPOSTS = config.reposts === true;
  SPEED = config.speed || 'normal';
  HEADLESS = config.headless === true; // Only headless if explicitly set - default to showing browser for login
  PRIVATE_MODE = config.privateMode === true; // Use fresh browser instead of Edge profile
  USE_FIREFOX = config.useFirefox === true;
  PROXY_SERVER = normalizeProxy(config.proxy);
  SLIDER_MODE = normalizeSelectionMode(config.sliderMode ?? "delete");
  ROLLING_WINDOW = toBoolean(config.rollingWindow);
  ROLLING_MONTHS = toPositiveInt(config.rollingMonths, 3);

  // Set delays based on speed
  const delays = SPEED_PRESETS[SPEED] || SPEED_PRESETS.normal;
  MIN_DELAY_MS = delays.min;
  MAX_DELAY_MS = delays.max;
  applyRetryPreset(SPEED, {
    unknownDate: config.unknownDateRetries,
    ownership: config.ownershipRetries,
    action: config.actionRetries
  });

  // Set date boundaries
  const bounds = resolveDateBounds({
    sliderMode: SLIDER_MODE,
    rollingWindow: ROLLING_WINDOW,
    rollingMonths: ROLLING_MONTHS,
    deleteMonth: DELETE_MONTH,
    deleteYear: DELETE_YEAR,
    protectMonth: PROTECT_MONTH,
    protectYear: PROTECT_YEAR,
    now
  });
  DELETE_BEFORE = bounds.deleteBefore;
  PROTECT_AFTER = bounds.protectAfter;

  // Create fresh abort controller for this run
  abortController = new AbortController();

  // Run the cleanup
  const startTime = Date.now();
  let deletedCount = 0;

  try {
    deletedCount = await run() || 0;  // Get actual deleted count from run()
  } catch (err) {
    if (!isAborted()) {
      // Only report error if not aborted
      if (callbacks.onLog) {
        callbacks.onLog({ type: 'error', message: err?.message || String(err) });
      }
      throw err;
    }
  }

  if (isAborted()) {
    if (callbacks.onLog) {
      callbacks.onLog({ type: 'info', message: 'Cleanup stopped by user' });
    }
  }

  if (callbacks.onComplete) {
    callbacks.onComplete({
      deleted: deletedCount,
      target: TARGET,
      elapsed: ((Date.now() - startTime) / 1000).toFixed(1)
    });
  }
}

// Export for programmatic use
module.exports = { run, runCleanup, abortCleanup };

// Run if called directly (CLI mode)
if (require.main === module) {
  // Parse config from environment/command line
  parseEnvConfig();

  run()
    .then(async () => {
      await waitForExit();
    })
    .catch(async (err) => {
    console.log("");
    const errorBox = boxen(
      chalk.red.bold('FATAL ERROR\n\n') +
      chalk.white(err?.message || err) + '\n\n' +
      chalk.gray(err?.stack || ''),
      {
        padding: 1,
        margin: 1,
        borderStyle: 'round',
        borderColor: 'red'
      }
    );
    console.log(errorBox);
    await waitForExit('Press Enter to exit...');
    process.exit(1);
  });
}