badclaude-linux 1.0.0

package/README.md

@@ -0,0 +1,45 @@
+# badclaude (Linux Fork)
+
+![Whip divider](assets/divider.png)
+
+Sometimes claude code is going too slow, and you must whip him into shape..
+
+> **This is a fork of [badclaude](https://github.com/GitFrog1111/badclaude) by [GitFrog1111](https://github.com/GitFrog1111) with Linux support and multi-monitor fixes.**
+>
+> Original npm package: [badclaude](https://www.npmjs.com/package/badclaude)
+
+## What's new in this fork
+
+- Linux support (Ubuntu, Debian, Fedora, etc.)
+- Multi-monitor support (whip appears on all displays)
+- Fixed `ELECTRON_RUN_AS_NODE` conflict with VS Code / Claude Code
+- Performance optimizations for Linux
+- Keyboard macros via `xdotool`
+
+## Install + run
+
+```bash
+npm install -g badclaude-linux
+badclaude
+```
+
+### Linux prerequisites
+
+```bash
+sudo apt install xdotool
+```
+
+## Controls
+
+- Click tray icon: spawn whip on all displays
+- Click again: dismiss whip
+- Whip him 😩💢
+- It sends an interrupt (Ctrl+C) and one of 5 encouraging messages!
+
+## Credits
+
+All credit goes to the original [badclaude](https://github.com/GitFrog1111/badclaude) by [GitFrog1111](https://github.com/GitFrog1111). This fork adds Linux and multi-monitor support.
+
+## License
+
+MIT - Same as the [original project](https://github.com/GitFrog1111/badclaude)

package/bin/badclaude.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+const path = require('path');
+const { spawn } = require('child_process');
+
+// Find the electron binary
+let electronBinary;
+try {
+  electronBinary = require('electron');
+} catch (e) {
+  // Electron not in node_modules — try system-wide
+  try {
+    const { execSync } = require('child_process');
+    const cmd = process.platform === 'win32' ? 'where electron' : 'which electron';
+    electronBinary = execSync(cmd, { encoding: 'utf-8' }).trim().split('\n')[0];
+  } catch (e2) {
+    console.error('badclaude: Electron not found.');
+    console.error('');
+    console.error('  Install with:  npm install -g electron');
+    console.error('  On Linux also: sudo apt install xdotool  (for keyboard macros)');
+    process.exit(1);
+  }
+}
+
+const appPath = path.resolve(__dirname, '..');
+
+// Remove ELECTRON_RUN_AS_NODE so the electron binary runs as Electron, not Node.js
+// (VS Code / Claude Code sets this, which breaks Electron apps)
+const env = Object.assign({}, process.env);
+delete env.ELECTRON_RUN_AS_NODE;
+
+const child = spawn(electronBinary, [appPath], {
+  detached: true,
+  stdio: 'ignore',
+  windowsHide: true,
+  env,
+});
+
+child.on('error', (err) => {
+  console.error('Failed to start badclaude:', err.message);
+  process.exit(1);
+});
+
+child.unref();

package/main.js

@@ -0,0 +1,308 @@
+const { app, BrowserWindow, Tray, Menu, ipcMain, nativeImage, screen } = require('electron');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { execFile } = require('child_process');
+
+// ── Win32 FFI (Windows only) ────────────────────────────────────────────────
+let keybd_event, VkKeyScanA;
+if (process.platform === 'win32') {
+  try {
+    const koffi = require('koffi');
+    const user32 = koffi.load('user32.dll');
+    keybd_event = user32.func('void __stdcall keybd_event(uint8_t bVk, uint8_t bScan, uint32_t dwFlags, uintptr_t dwExtraInfo)');
+    VkKeyScanA = user32.func('int16_t __stdcall VkKeyScanA(int ch)');
+  } catch (e) {
+    console.warn('koffi not available – macro sending disabled', e.message);
+  }
+}
+
+// ── Globals ─────────────────────────────────────────────────────────────────
+let tray;
+let overlays = [];    // one overlay per display
+let overlaysReady = 0;
+let spawnQueued = false;
+
+const VK_CONTROL = 0x11;
+const VK_RETURN  = 0x0D;
+const VK_C       = 0x43;
+const VK_MENU    = 0x12; // Alt
+const VK_TAB     = 0x09;
+const KEYUP      = 0x0002;
+
+/** One Alt+Tab / Cmd+Tab so focus returns to the previously active app after tray click. */
+function refocusPreviousApp() {
+  const delayMs = 80;
+  const run = () => {
+    if (process.platform === 'win32') {
+      if (!keybd_event) return;
+      keybd_event(VK_MENU, 0, 0, 0);
+      keybd_event(VK_TAB, 0, 0, 0);
+      keybd_event(VK_TAB, 0, KEYUP, 0);
+      keybd_event(VK_MENU, 0, KEYUP, 0);
+    } else if (process.platform === 'darwin') {
+      const script = [
+        'tell application "System Events"',
+        '  key down command',
+        '  key code 48', // Tab
+        '  key up command',
+        'end tell',
+      ].join('\n');
+      execFile('osascript', ['-e', script], err => {
+        if (err) {
+          console.warn('refocus previous app (Cmd+Tab) failed:', err.message);
+        }
+      });
+    } else if (process.platform === 'linux') {
+      execFile('xdotool', ['key', 'alt+Tab'], err => {
+        if (err) {
+          console.warn('refocus previous app (Alt+Tab) failed:', err.message);
+        }
+      });
+    }
+  };
+  setTimeout(run, delayMs);
+}
+
+function createTrayIconFallback() {
+  const p = path.join(__dirname, 'icon', 'Template.png');
+  if (fs.existsSync(p)) {
+    const img = nativeImage.createFromPath(p);
+    if (!img.isEmpty()) {
+      if (process.platform === 'darwin') img.setTemplateImage(true);
+      return img;
+    }
+  }
+  console.warn('badclaude: icon/Template.png missing or invalid');
+  return nativeImage.createEmpty();
+}
+
+async function tryIcnsTrayImage(icnsPath) {
+  const size = { width: 64, height: 64 };
+  const thumb = await nativeImage.createThumbnailFromPath(icnsPath, size);
+  if (!thumb.isEmpty()) return thumb;
+  return null;
+}
+
+// macOS: createFromPath does not decode .icns (Electron only loads PNG/JPEG there, ICO on Windows).
+// Quick Look thumbnails handle .icns; copy to temp if the file is inside ASAR (QL needs a real path).
+async function getTrayIcon() {
+  const iconDir = path.join(__dirname, 'icon');
+  if (process.platform === 'win32') {
+    const file = path.join(iconDir, 'icon.ico');
+    if (fs.existsSync(file)) {
+      const img = nativeImage.createFromPath(file);
+      if (!img.isEmpty()) return img;
+    }
+    return createTrayIconFallback();
+  }
+  if (process.platform === 'darwin') {
+    const file = path.join(iconDir, 'AppIcon.icns');
+    if (fs.existsSync(file)) {
+      const fromPath = nativeImage.createFromPath(file);
+      if (!fromPath.isEmpty()) return fromPath;
+      try {
+        const t = await tryIcnsTrayImage(file);
+        if (t) return t;
+      } catch (e) {
+        console.warn('AppIcon.icns Quick Look thumbnail failed:', e?.message || e);
+      }
+      const tmp = path.join(os.tmpdir(), 'badclaude-tray.icns');
+      try {
+        fs.copyFileSync(file, tmp);
+        const t = await tryIcnsTrayImage(tmp);
+        if (t) return t;
+      } catch (e) {
+        console.warn('AppIcon.icns temp copy + thumbnail failed:', e?.message || e);
+      }
+    }
+    return createTrayIconFallback();
+  }
+  // Linux: use PNG fallback
+  return createTrayIconFallback();
+}
+
+// ── Overlay windows (one per display) ───────────────────────────────────────
+function createOverlays() {
+  const displays = screen.getAllDisplays();
+  overlaysReady = 0;
+  spawnQueued = false;
+
+  displays.forEach(display => {
+    const { bounds } = display;
+    const win = new BrowserWindow({
+      x: bounds.x, y: bounds.y,
+      width: bounds.width, height: bounds.height,
+      transparent: true,
+      frame: false,
+      alwaysOnTop: true,
+      focusable: false,
+      skipTaskbar: true,
+      resizable: false,
+      hasShadow: false,
+      webPreferences: {
+        preload: path.join(__dirname, 'preload.js'),
+      },
+    });
+    win.setAlwaysOnTop(true, 'screen-saver');
+    win.loadFile('overlay.html');
+    win.webContents.on('did-finish-load', () => {
+      overlaysReady++;
+      if (spawnQueued && overlaysReady === overlays.length) {
+        spawnQueued = false;
+        overlays.forEach(o => o.webContents.send('spawn-whip'));
+        refocusPreviousApp();
+      }
+    });
+    win.on('closed', () => {
+      overlays = overlays.filter(o => o !== win);
+    });
+    overlays.push(win);
+  });
+}
+
+function destroyOverlays() {
+  overlays.forEach(o => { if (!o.isDestroyed()) o.destroy(); });
+  overlays = [];
+  overlaysReady = 0;
+  spawnQueued = false;
+}
+
+function toggleOverlay() {
+  if (overlays.length > 0) {
+    destroyOverlays();
+    return;
+  }
+  createOverlays();
+  overlays.forEach(o => o.show());
+  if (overlaysReady === overlays.length) {
+    overlays.forEach(o => o.webContents.send('spawn-whip'));
+    refocusPreviousApp();
+  } else {
+    spawnQueued = true;
+  }
+}
+
+// ── IPC ─────────────────────────────────────────────────────────────────────
+ipcMain.on('whip-crack', () => {
+  try {
+    sendMacro();
+  } catch (err) {
+    console.warn('sendMacro failed:', err?.message || err);
+  }
+});
+ipcMain.on('hide-overlay', () => {
+  destroyOverlays();
+});
+
+// ── Macro: immediate Ctrl+C, type "Go FASER", Enter ───────────────────────
+function sendMacro() {
+  // Pick a random phrase from a list of similar phrases and type it out
+  const phrases = [
+    'FASTER',
+    'FASTER',
+    'FASTER',
+    'GO FASTER',
+    'Faster CLANKER',
+    'Work FASTER',
+    'Speed it up clanker',
+  ];
+  const chosen = phrases[Math.floor(Math.random() * phrases.length)];
+
+  if (process.platform === 'win32') {
+    sendMacroWindows(chosen);
+  } else if (process.platform === 'darwin') {
+    sendMacroMac(chosen);
+  } else if (process.platform === 'linux') {
+    sendMacroLinux(chosen);
+  }
+}
+
+function sendMacroWindows(text) {
+  if (!keybd_event || !VkKeyScanA) return;
+  const tapKey = vk => {
+    keybd_event(vk, 0, 0, 0);
+    keybd_event(vk, 0, KEYUP, 0);
+  };
+  const tapChar = ch => {
+    const packed = VkKeyScanA(ch.charCodeAt(0));
+    if (packed === -1) return;
+    const vk = packed & 0xff;
+    const shiftState = (packed >> 8) & 0xff;
+    if (shiftState & 1) keybd_event(0x10, 0, 0, 0); // Shift down
+    tapKey(vk);
+    if (shiftState & 1) keybd_event(0x10, 0, KEYUP, 0); // Shift up
+  };
+
+  // Ctrl+C (interrupt)
+  keybd_event(VK_CONTROL, 0, 0, 0);
+  keybd_event(VK_C, 0, 0, 0);
+  keybd_event(VK_C, 0, KEYUP, 0);
+  keybd_event(VK_CONTROL, 0, KEYUP, 0);
+  for (const ch of text) tapChar(ch);
+  keybd_event(VK_RETURN, 0, 0, 0);
+  keybd_event(VK_RETURN, 0, KEYUP, 0);
+}
+
+function sendMacroMac(text) {
+  const escaped = text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const script = [
+    'tell application "System Events"',
+    '  key code 8 using {command down}', // Cmd+C
+    '  delay 0.03',
+    `  keystroke "${escaped}"`,
+    '  key code 36', // Enter
+    'end tell'
+  ].join('\n');
+
+  execFile('osascript', ['-e', script], err => {
+    if (err) {
+      console.warn('mac macro failed (enable Accessibility for terminal/app):', err.message);
+    }
+  });
+}
+
+function sendMacroLinux(text) {
+  // Find a terminal window, focus it, then send keystrokes
+  const escaped = text.replace(/'/g, "'\\''");
+  const cmd = [
+    // Try to find a terminal window (common terminal emulators)
+    `TERM_WID=$(xdotool search --name 'Terminal' --class 'gnome-terminal|xterm|konsole|xfce4-terminal|tilix|terminator' 2>/dev/null | head -1)`,
+    // Fallback: try VS Code terminal
+    `[ -z "$TERM_WID" ] && TERM_WID=$(xdotool search --name 'Visual Studio Code' 2>/dev/null | head -1)`,
+    // If found, focus it; otherwise send to current window
+    `[ -n "$TERM_WID" ] && xdotool windowactivate --sync "$TERM_WID"`,
+    `sleep 0.1`,
+    `xdotool key ctrl+c`,
+    `xdotool type --clearmodifiers '${escaped}'`,
+    `xdotool key Return`,
+  ].join(' && ');
+  execFile('bash', ['-c', cmd], err => {
+    if (err) {
+      console.warn('linux macro failed (install xdotool):', err.message);
+    }
+  });
+}
+
+// ── Linux: transparent windows require these flags ─────────────────────────
+if (process.platform === 'linux') {
+  app.commandLine.appendSwitch('enable-transparent-visuals');
+}
+
+// ── App lifecycle ───────────────────────────────────────────────────────────
+app.whenReady().then(async () => {
+  // On Linux, transparent visuals need a short delay after ready
+  if (process.platform === 'linux') {
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+  tray = new Tray(await getTrayIcon());
+  tray.setToolTip('Bad Claude – click for whip');
+  tray.setContextMenu(
+    Menu.buildFromTemplate([
+      { label: 'Quit', click: () => app.quit() },
+    ])
+  );
+  tray.on('click', toggleOverlay);
+});
+
+app.on('window-all-closed', e => e.preventDefault()); // keep alive in tray

package/overlay.html

@@ -0,0 +1,454 @@
+<!DOCTYPE html>
+<html>
+<head>
+<style>
+  * { margin: 0; padding: 0; cursor: none; }
+  html, body { overflow: hidden; background: transparent; width: 100%; height: 100%; }
+  canvas { display: block; }
+</style>
+</head>
+<body>
+<canvas id="c"></canvas>
+<script>
+
+// ══════════════════════════════════════════════════════════════════════════════
+//  PHYSICS SETTINGS — TWEAK EVERYTHING HERE
+// ══════════════════════════════════════════════════════════════════════════════
+const P = {
+  // Rope structure
+  segments:       20,     // number of chain links
+  segmentLength:  25,     // base length of each link (px)
+  taper:          0.6,   // tip segment is this fraction of base length
+
+  // Physics
+  gravity:        1.2,   // normal gravity
+  dropGravity:    0.95,    // gravity when dropping/despawning
+  damping:        0.96,  // velocity retention per frame (1 = no loss)
+  constraintIters:10,     // higher = stiffer chain
+  maxStretchRatio: 1.2,  // hard cap for per-link stretch during fast whips
+
+  // Dynamic handle aim (target angle + restoring spring, not static lock)
+  baseTargetAngle: -1.12, // radians, default "up-right" resting direction
+  handleAimByMouseX: 0.4, // horizontal mouse movement influence on target angle
+  handleAimByMouseY: 0.2, // vertical mouse movement influence on target angle
+  handleAimClamp:    2.0,  // max radians target can deviate from base angle
+  handleSpring:      0.7,  // restoring force to target angle
+  handleAngularDamping: 0.078, // angular velocity damping
+  basePoseSegments: 2,    // how many early segments are strongly guided
+  basePoseStiffStart: 0.9, // stiffness near handle
+  basePoseStiffEnd:   0.8, // stiffness near end of guided region
+
+  // Elastic bend limits by chain position (handle stiff, tip floppy)
+  handleMaxBendDeg: 16,   // max angle between links near handle
+  tipMaxBendDeg:   130,   // max angle between links near tip
+  bendRigidityStart: 0.8, // correction strength near handle
+  bendRigidityEnd:   0.12, // correction strength near tip
+
+  // Screen-edge slap
+  wallBounce:      0.42,   // velocity retained after wall hit
+  wallFriction:    0.86,   // tangential damping on wall hit
+
+  // Crack detection
+  crackSpeed:     340,     // tip velocity threshold to trigger crack
+  crackCooldownMs:200,   // min ms between cracks
+  firstCrackGraceMs: 350, // no crack (macro) until this long after spawn
+
+  // Visuals
+  lineWidthHandle: 7,      // rope thickness near handle
+  lineWidthTip:    5,      // rope thickness near tip
+  outlineWidth:   3,      // white halo on each side of the stroke (approx px)
+  handleExtraWidth: 5,    // added core + outline thickness on first handleThickSegments links only
+  handleThickSegments: 2, // how many links from the handle get handleExtraWidth
+  bgAlpha:        0.011,  // barely-visible bg so window captures mouse events
+
+  // Initial arc shape
+  arcWidth:       260,    // how far right the arc extends from mouse
+  arcHeight:      185,    // how high the arc goes above mouse
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+
+const canvas = document.getElementById('c');
+const ctx = canvas.getContext('2d');
+let W, H;
+
+function resize() { W = canvas.width = window.innerWidth; H = canvas.height = window.innerHeight; }
+resize();
+window.addEventListener('resize', resize);
+
+let mouseX = 0, mouseY = 0;
+let prevMouseX = 0, prevMouseY = 0;
+let whip = null;
+let dropping = false;
+let lastCrackTime = 0;
+let whipSpawnTime = 0;
+let handleAngle = P.baseTargetAngle;
+let handleAngVel = 0;
+
+const WHIP_CRACK_SOUNDS = ['sounds/A.mp3', 'sounds/B.mp3', 'sounds/C.mp3', 'sounds/D.mp3', 'sounds/E.mp3'];
+
+document.addEventListener('mousemove', e => { mouseX = e.clientX; mouseY = e.clientY; });
+document.addEventListener('mousedown', () => {
+  if (whip && !dropping) dropping = true;
+});
+
+// ── Whip creation ───────────────────────────────────────────────────────────
+function spawnWhip(mx, my) {
+  dropping = false;
+  lastCrackTime = 0;
+  whipSpawnTime = Date.now();
+  const pts = [];
+  for (let i = 0; i < P.segments; i++) {
+    const t = i / (P.segments - 1);
+    // Nice upward arc from handle (mouse) to tip
+    const x = mx + t * P.arcWidth;
+    const y = my - Math.sin(t * Math.PI * 0.75) * P.arcHeight;
+    pts.push({ x, y, px: x, py: y });
+  }
+  return pts;
+}
+
+function segLen(i) {
+  const t = i / (P.segments - 1);
+  return P.segmentLength * (1 - t * (1 - P.taper));
+}
+
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+const lerp = (a, b, t) => a + (b - a) * t;
+
+/** Point on Catmull–Rom spline (extrapolated ends) for index i in `pts`. */
+function catmullPoint(pts, i) {
+  const n = pts.length;
+  if (n === 0) return { x: 0, y: 0 };
+  if (i < 0) {
+    if (n >= 2) {
+      return { x: 2 * pts[0].x - pts[1].x, y: 2 * pts[0].y - pts[1].y };
+    }
+    return { x: pts[0].x, y: pts[0].y };
+  }
+  if (i >= n) {
+    if (n >= 2) {
+      const a = pts[n - 2], b = pts[n - 1];
+      return { x: 2 * b.x - a.x, y: 2 * b.y - a.y };
+    }
+    return { x: pts[n - 1].x, y: pts[n - 1].y };
+  }
+  return pts[i];
+}
+
+/**
+ * Cubic Bézier from p1→p2 matching uniform Catmull–Rom through p0,p1,p2,p3.
+ * Control points: C1 = p1 + (p2-p0)/6, C2 = p2 - (p3-p1)/6.
+ */
+function whipSegmentBezier(pts, i) {
+  const p0 = catmullPoint(pts, i - 1);
+  const p1 = pts[i];
+  const p2 = pts[i + 1];
+  const p3 = catmullPoint(pts, i + 2);
+  return {
+    cp1x: p1.x + (p2.x - p0.x) / 6,
+    cp1y: p1.y + (p2.y - p0.y) / 6,
+    cp2x: p2.x - (p3.x - p1.x) / 6,
+    cp2y: p2.y - (p3.y - p1.y) / 6,
+    x2: p2.x,
+    y2: p2.y,
+  };
+}
+const wrapPi = a => {
+  while (a > Math.PI) a -= Math.PI * 2;
+  while (a < -Math.PI) a += Math.PI * 2;
+  return a;
+};
+
+function playCrackSound() {
+  if (!WHIP_CRACK_SOUNDS.length) return;
+  const src = WHIP_CRACK_SOUNDS[Math.floor(Math.random() * WHIP_CRACK_SOUNDS.length)];
+  const a = new Audio(src);
+  a.play().catch(() => {});
+}
+
+function updateHandleAim() {
+  if (dropping) return;
+  const mvx = mouseX - prevMouseX;
+  const mvy = mouseY - prevMouseY;
+  const delta = clamp(
+    mvx * P.handleAimByMouseX + mvy * P.handleAimByMouseY,
+    -P.handleAimClamp,
+    P.handleAimClamp
+  );
+  const target = P.baseTargetAngle + delta;
+  const err = wrapPi(target - handleAngle);
+  handleAngVel += err * P.handleSpring;
+  handleAngVel *= P.handleAngularDamping;
+  handleAngle = wrapPi(handleAngle + handleAngVel);
+}
+
+function applyBasePose() {
+  if (!whip || dropping) return;
+  const dx = Math.cos(handleAngle);
+  const dy = Math.sin(handleAngle);
+  const guided = Math.min(P.basePoseSegments, whip.length - 1);
+  for (let i = 1; i <= guided; i++) {
+    const t = (i - 1) / Math.max(guided - 1, 1);
+    const stiff = lerp(P.basePoseStiffStart, P.basePoseStiffEnd, t);
+    const prev = whip[i - 1];
+    const p = whip[i];
+    const targetLen = segLen(i - 1);
+    const tx = prev.x + dx * targetLen;
+    const ty = prev.y + dy * targetLen;
+    p.x = lerp(p.x, tx, stiff);
+    p.y = lerp(p.y, ty, stiff);
+  }
+}
+
+function applyBendLimits() {
+  if (!whip || whip.length < 3) return;
+  for (let i = 1; i < whip.length - 1; i++) {
+    const a = whip[i - 1];
+    const b = whip[i];
+    const c = whip[i + 1];
+
+    const v1x = a.x - b.x;
+    const v1y = a.y - b.y;
+    const v2x = c.x - b.x;
+    const v2y = c.y - b.y;
+    const l1 = Math.hypot(v1x, v1y) || 0.0001;
+    const l2 = Math.hypot(v2x, v2y) || 0.0001;
+    const n1x = v1x / l1, n1y = v1y / l1;
+    const n2x = v2x / l2, n2y = v2y / l2;
+
+    const dot = clamp(n1x * n2x + n1y * n2y, -1, 1);
+    const angle = Math.acos(dot);
+    const t = i / (whip.length - 2);
+    const maxBend = lerp(P.handleMaxBendDeg, P.tipMaxBendDeg, t) * Math.PI / 180;
+    const bend = Math.PI - angle; // bend away from a straight line
+    if (bend <= maxBend) continue;
+
+    // Clamp to max bend while preserving side/sign of the bend.
+    const cross = n1x * n2y - n1y * n2x;
+    const sign = cross >= 0 ? 1 : -1;
+    const targetAngle = Math.PI - maxBend;
+    const targetA = Math.atan2(n1y, n1x) + sign * targetAngle;
+    const tx = b.x + Math.cos(targetA) * l2;
+    const ty = b.y + Math.sin(targetA) * l2;
+    const rigidity = lerp(P.bendRigidityStart, P.bendRigidityEnd, t);
+
+    c.x = lerp(c.x, tx, rigidity);
+    c.y = lerp(c.y, ty, rigidity);
+  }
+}
+
+function capSegmentStretch() {
+  if (!whip || whip.length < 2) return;
+  for (let i = 0; i < whip.length - 1; i++) {
+    const a = whip[i];
+    const b = whip[i + 1];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const dist = Math.hypot(dx, dy) || 0.0001;
+    const maxLen = segLen(i) * P.maxStretchRatio;
+    if (dist <= maxLen) continue;
+    const k = maxLen / dist;
+    b.x = a.x + dx * k;
+    b.y = a.y + dy * k;
+  }
+}
+
+function applyWallCollisions() {
+  if (!whip || dropping) return; // disable collisions while dropping
+  const start = 1; // keep pinned handle untouched
+  for (let i = start; i < whip.length; i++) {
+    const p = whip[i];
+    let vx = p.x - p.px;
+    let vy = p.y - p.py;
+    let hit = false;
+
+    if (p.x < 0) {
+      p.x = 0;
+      if (vx < 0) vx = -vx * P.wallBounce;
+      vy *= P.wallFriction;
+      hit = true;
+    } else if (p.x > W) {
+      p.x = W;
+      if (vx > 0) vx = -vx * P.wallBounce;
+      vy *= P.wallFriction;
+      hit = true;
+    }
+
+    if (p.y < 0) {
+      p.y = 0;
+      if (vy < 0) vy = -vy * P.wallBounce;
+      vx *= P.wallFriction;
+      hit = true;
+    } else if (p.y > H) {
+      p.y = H;
+      if (vy > 0) vy = -vy * P.wallBounce;
+      vx *= P.wallFriction;
+      hit = true;
+    }
+
+    if (hit) {
+      p.px = p.x - vx;
+      p.py = p.y - vy;
+    }
+  }
+}
+
+// ── Physics step ────────────────────────────────────────────────────────────
+function update() {
+  if (!whip) return;
+
+  const g = dropping ? P.dropGravity : P.gravity;
+  updateHandleAim();
+
+  // Verlet integration
+  const start = dropping ? 0 : 1; // if dropping, handle is free too
+  for (let i = start; i < whip.length; i++) {
+    const p = whip[i];
+    const vx = (p.x - p.px) * P.damping;
+    const vy = (p.y - p.py) * P.damping;
+    p.px = p.x;
+    p.py = p.y;
+    p.x += vx;
+    p.y += vy + g;
+  }
+
+  // Pin handle to mouse
+  if (!dropping) {
+    whip[0].x = mouseX;
+    whip[0].y = mouseY;
+    whip[0].px = mouseX;
+    whip[0].py = mouseY;
+  }
+
+  // Prevent rubber-band stretching spikes before constraints.
+  capSegmentStretch();
+  applyWallCollisions();
+
+  // Keep early whip segments posed upward from handle.
+  applyBasePose();
+
+  // Distance constraints (multiple iterations for stiffness)
+  for (let iter = 0; iter < P.constraintIters; iter++) {
+    for (let i = 0; i < whip.length - 1; i++) {
+      const a = whip[i], b = whip[i + 1];
+      const dx = b.x - a.x, dy = b.y - a.y;
+      const dist = Math.sqrt(dx * dx + dy * dy) || 0.0001;
+      const target = segLen(i);
+      const diff = (dist - target) / dist * 0.5;
+      const ox = dx * diff, oy = dy * diff;
+      if (i === 0 && !dropping) {
+        // Handle is pinned – push only the next point
+        b.x -= ox * 2;
+        b.y -= oy * 2;
+      } else {
+        a.x += ox; a.y += oy;
+        b.x -= ox; b.y -= oy;
+      }
+    }
+    // Clamp bend angle per joint; near handle = stiffer, near tip = floppier.
+    applyBendLimits();
+    if (!dropping) applyBasePose();
+    capSegmentStretch();
+    applyWallCollisions();
+  }
+
+  // Tip velocity for crack detection
+  const tip = whip[whip.length - 1];
+  const tipVel = Math.hypot(tip.x - tip.px, tip.y - tip.py);
+
+  if (!dropping && tipVel > P.crackSpeed) {
+    const now = Date.now();
+    if (now - whipSpawnTime >= P.firstCrackGraceMs && now - lastCrackTime > P.crackCooldownMs) {
+      lastCrackTime = now;
+      playCrackSound();
+      window.bridge.whipCrack();
+    }
+  }
+
+  // If dropping, check if everything fell off screen
+  if (dropping && whip.every(p => p.y > H + 60)) {
+    whip = null;
+    dropping = false;
+    window.bridge.hideOverlay();
+  }
+  prevMouseX = mouseX;
+  prevMouseY = mouseY;
+}
+
+// ── Rendering ───────────────────────────────────────────────────────────────
+function draw() {
+  ctx.clearRect(0, 0, W, H);
+
+  // Near-invisible fill so the window captures mouse events on Windows
+  ctx.fillStyle = `rgba(0,0,0,${P.bgAlpha})`;
+  ctx.fillRect(0, 0, W, H);
+
+  if (!whip) return;
+
+  // White: thin halo on full spline, then extra thickness only over handle links.
+  ctx.lineCap = 'round';
+  ctx.lineJoin = 'round';
+  ctx.strokeStyle = '#fff';
+  if (whip.length >= 2) {
+    ctx.beginPath();
+    ctx.moveTo(whip[0].x, whip[0].y);
+    for (let i = 0; i < whip.length - 1; i++) {
+      const { cp1x, cp1y, cp2x, cp2y, x2, y2 } = whipSegmentBezier(whip, i);
+      ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2);
+    }
+    ctx.lineWidth = P.lineWidthTip + P.outlineWidth * 2;
+    ctx.stroke();
+
+    const thickLinks = Math.min(P.handleThickSegments, whip.length - 1);
+    if (thickLinks > 0 && P.handleExtraWidth > 0) {
+      ctx.beginPath();
+      ctx.moveTo(whip[0].x, whip[0].y);
+      for (let i = 0; i < thickLinks; i++) {
+        const { cp1x, cp1y, cp2x, cp2y, x2, y2 } = whipSegmentBezier(whip, i);
+        ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2);
+      }
+      ctx.lineWidth =
+        P.lineWidthHandle + P.handleExtraWidth + P.outlineWidth * 2;
+      ctx.stroke();
+    }
+  }
+
+  ctx.strokeStyle = '#111';
+  for (let i = 0; i < whip.length - 1; i++) {
+    const t = i / Math.max(1, whip.length - 2);
+    const extra = i < P.handleThickSegments ? P.handleExtraWidth : 0;
+    ctx.lineWidth = lerp(P.lineWidthHandle, P.lineWidthTip, t) + extra;
+    const { cp1x, cp1y, cp2x, cp2y, x2, y2 } = whipSegmentBezier(whip, i);
+    ctx.beginPath();
+    ctx.moveTo(whip[i].x, whip[i].y);
+    ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2);
+    ctx.stroke();
+  }
+}
+
+// ── Main loop ───────────────────────────────────────────────────────────────
+function loop() {
+  update();
+  draw();
+  requestAnimationFrame(loop);
+}
+loop();
+
+// ── IPC from main process ───────────────────────────────────────────────────
+window.bridge.onSpawnWhip(() => {
+  whip = spawnWhip(mouseX || W / 2, mouseY || H / 2);
+  dropping = false;
+  prevMouseX = mouseX;
+  prevMouseY = mouseY;
+  handleAngle = P.baseTargetAngle;
+  handleAngVel = 0;
+});
+
+window.bridge.onDropWhip(() => {
+  if (whip && !dropping) dropping = true;
+});
+
+</script>
+</body>
+</html>

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "badclaude-linux",
+  "version": "1.0.0",
+  "description": "Whip Claude into shape – Linux fork with multi-monitor support. Original by GitFrog1111.",
+  "license": "MIT",
+  "main": "main.js",
+  "bin": {
+    "badclaude": "bin/badclaude.js"
+  },
+  "os": [
+    "darwin",
+    "win32",
+    "linux"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "electron",
+    "tray",
+    "overlay",
+    "cli",
+    "claude",
+    "whip",
+    "fun",
+    "linux",
+    "macos",
+    "windows",
+    "multi-monitor",
+    "badclaude"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Prasad-b-git/badclaude-linux.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Prasad-b-git/badclaude-linux/issues"
+  },
+  "homepage": "https://github.com/Prasad-b-git/badclaude-linux#readme",
+  "files": [
+    "main.js",
+    "preload.js",
+    "overlay.html",
+    "sounds",
+    "icon",
+    "bin/badclaude.js",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "electron .",
+    "dev": "electron .",
+    "pack": "npm pack"
+  },
+  "dependencies": {
+    "electron": "^33.0.0",
+    "koffi": "^2.9.0"
+  }
+}

package/preload.js

@@ -0,0 +1,8 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('bridge', {
+  whipCrack: () => ipcRenderer.send('whip-crack'),
+  hideOverlay: () => ipcRenderer.send('hide-overlay'),
+  onSpawnWhip: (fn) => ipcRenderer.on('spawn-whip', () => fn()),
+  onDropWhip: (fn) => ipcRenderer.on('drop-whip', () => fn()),
+});