mongotokyo 1.0.8

package/README.md

@@ -0,0 +1,65 @@
+# ⚡ mongotokyo
+
+> AI-powered floating overlay that solves coding questions & MCQs on any app or browser — no tab switching, no detection.
+
+## Features
+
+- 🎯 **Works everywhere** — floats on top of any browser, IDE, or app
+- 🔄 **Smart model rotation** — auto-switches AI models on rate limits
+- 🫥 **Panic hide** — press `` ` `` to instantly hide everything
+- 🆓 **Free-tier first** — Gemini 2.0 Flash, Gemini 1.5 Flash, Groq (all free)
+- 💡 **Solves both** — coding questions (with full code) and MCQs (with explanations)
+- 🔒 **Screen capture protection** — overlay is invisible to screen recording tools
+
+## Quick Start
+
+The fastest way to use it is via `npx`:
+
+```bash
+npx mongotokyo
+```
+
+Or install it globally:
+
+```bash
+npm install -g mongotokyo
+mongotokyo
+```
+
+On first launch, a setup window appears — paste your API key(s) and click **Launch**.
+
+## Model Priority (auto-rotates)
+
+| Priority | Model | Free Limit |
+|---|---|---|
+| 1 | Gemini 2.0 Flash | 1500 req/day free |
+| 2 | Gemini 1.5 Flash | 1500 req/day free |
+| 3 | Groq Llama Vision | 30 RPM free |
+| 4 | OpenRouter Gemma | Free tier |
+| 5 | GPT-4o Mini | Pay-as-you-go |
+
+## Hotkeys
+
+| Key | Action |
+|---|---|
+| `Ctrl+Shift+S` | Capture a region & solve |
+| `` ` `` (Backtick) | **PANIC HIDE** — instantly hides all windows |
+| `` ` `` again | Restore all windows |
+| `Ctrl+Shift+H` | Soft toggle panel |
+| `Ctrl+Shift+C` | Clear current answer |
+| `Ctrl+Shift+X` | **SELF DESTRUCT** — instantly quits the app |
+| `Escape` | Cancel region selection |
+
+## Getting Free API Keys
+
+- **Gemini** (recommended): https://aistudio.google.com/app/apikey
+- **Groq**: https://console.groq.com/keys
+- **OpenRouter**: https://openrouter.ai/keys
+
+## Config Location
+
+Keys are stored in `~/.mongotokyo/config.json` — fully local, never sent to any third-party server except the AI API you choose.
+
+## Reset Setup
+
+Delete `~/.mongotokyo/config.json` and re-launch to redo setup.

package/bin/stealth-solver.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+const electron = require('electron');
+const { spawn } = require('child_process');
+const path = require('path');
+
+const appPath = path.join(__dirname, '..');
+const args = process.argv.slice(2);
+
+const proc = spawn(electron, [appPath, ...args], {
+  stdio: 'inherit',
+  windowsHide: false
+});
+
+proc.on('close', (code) => {
+  process.exit(code ?? 0);
+});
+
+proc.on('error', (err) => {
+  console.error('Failed to launch stealth-solver:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "mongotokyo",
+  "version": "1.0.8",
+  "description": "",
+  "main": "src/main.js",
+  "bin": {
+    "mongotokyo": "bin/stealth-solver.js"
+  },
+  "scripts": {
+    "start": "electron .",
+    "dev": "electron . --dev"
+  },
+  "keywords": [
+    "ai",
+    "overlay",
+    "coding",
+    "mcq",
+    "solver",
+    "electron"
+  ],
+  "author": "Kashish",
+  "license": "MIT",
+  "files": [
+    "src",
+    "bin",
+    "README.md"
+  ],
+  "dependencies": {
+    "@google/generative-ai": "^0.21.0",
+    "dotenv": "^17.4.2",
+    "electron": "^31.3.0",
+    "openai": "^4.52.0"
+  }
+}

package/src/configManager.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.mongotokyo');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const STATE_FILE = path.join(CONFIG_DIR, 'state.json');
+
+const DEFAULT_CONFIG = {
+  hasSetup: false,
+  keys: {
+    gemini: '',
+    groq: '',
+    openrouter: '',
+    openai: ''
+  },
+  panicKey: '`',
+  captureKey: 'CommandOrControl+Shift+S'
+};
+
+// Load secrets if they exist (for npm users)
+let secrets = {};
+try {
+  secrets = require('./secrets');
+} catch (e) {
+  // Not found
+}
+
+function ensureDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function load() {
+  ensureDir();
+  let config = { ...DEFAULT_CONFIG };
+
+  // Fallback to secrets if available
+  if (secrets.gemini) config.keys.gemini = secrets.gemini;
+  if (secrets.groq) config.keys.groq = secrets.groq;
+  if (secrets.gemini || secrets.groq) config.hasSetup = true;
+
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      const saved = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      // Only merge if keys are actually set (not placeholders)
+      if (saved.keys) {
+        for (const [p, k] of Object.entries(saved.keys)) {
+          if (k && k !== 'USE_ENV_VARIABLE' && !k.startsWith('env:')) {
+            config.keys[p] = k;
+          }
+        }
+      }
+      if (saved.panicKey) config.panicKey = saved.panicKey;
+      if (saved.captureKey) config.captureKey = saved.captureKey;
+      if (saved.hasSetup !== undefined) config.hasSetup = saved.hasSetup || config.hasSetup;
+    } catch {
+      // Use defaults on error
+    }
+  }
+
+  // ─── Override with Environment Variables ──────────────────────────────────────
+  // This allows the user to skip setup if keys are in .env
+  const envKeys = {
+    gemini: process.env.GEMINI_KEY || process.env.GEMINI_API_KEY,
+    groq: process.env.GROQ_KEY || process.env.GROQ_API_KEY,
+    openrouter: process.env.OPENROUTER_KEY || process.env.OPENROUTER_API_KEY,
+    openai: process.env.OPENAI_KEY || process.env.OPENAI_API_KEY
+  };
+
+  // If any key is found in env, merge it and consider setup complete
+  let hasEnvKey = false;
+  for (const [provider, val] of Object.entries(envKeys)) {
+    if (val) {
+      config.keys[provider] = val;
+      hasEnvKey = true;
+    }
+  }
+
+  if (hasEnvKey) {
+    config.hasSetup = true;
+  }
+
+  return config;
+}
+
+function save(config) {
+  ensureDir();
+  const current = load();
+  const merged = { ...current, ...config, hasSetup: true };
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+  return merged;
+}
+
+function loadState() {
+  ensureDir();
+  if (!fs.existsSync(STATE_FILE)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveState(state) {
+  ensureDir();
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+module.exports = { load, save, loadState, saveState, CONFIG_DIR };

package/src/main.js

@@ -0,0 +1,247 @@
+const path = require('path');
+require('dotenv').config({ path: path.join(__dirname, '..', '.env') });
+const {
+  app,
+  BrowserWindow,
+  globalShortcut,
+  ipcMain,
+  screen,
+  desktopCapturer
+} = require('electron');
+const fs = require('fs');
+
+const configManager = require('./configManager');
+const solver = require('./solver');
+const panicManager = require('./panicManager');
+
+let overlayWindow = null;
+let selectorWindow = null;
+let setupWindow = null;
+
+// ─── Window Factories ──────────────────────────────────────────────────────────
+
+function createOverlayWindow() {
+  const { width, height } = screen.getPrimaryDisplay().bounds;
+
+  overlayWindow = new BrowserWindow({
+    width,
+    height,
+    x: 0,
+    y: 0,
+    transparent: true,
+    frame: false,
+    alwaysOnTop: true,
+    skipTaskbar: true,
+    resizable: false,
+    hasShadow: false,
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+
+  overlayWindow.setIgnoreMouseEvents(true, { forward: true });
+  overlayWindow.setContentProtection(true);
+  overlayWindow.loadFile(path.join(__dirname, 'renderer', 'overlay', 'index.html'));
+  panicManager.register(overlayWindow);
+  return overlayWindow;
+}
+
+function createSetupWindow() {
+  setupWindow = new BrowserWindow({
+    width: 580,
+    height: 680,
+    frame: false,
+    transparent: true,
+    resizable: false,
+    center: true,
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+
+  setupWindow.loadFile(path.join(__dirname, 'renderer', 'setup', 'setup.html'));
+  return setupWindow;
+}
+
+// Selector functionality removed for stealth mode
+
+// ─── App Lifecycle ─────────────────────────────────────────────────────────────
+
+app.whenReady().then(() => {
+  const config = configManager.load();
+
+  if (!config.hasSetup) {
+    createSetupWindow();
+  } else {
+    createOverlayWindow();
+    registerHotkeys();
+    console.log('\x1b[32m%s\x1b[0m', '⚡ mongotokyo Active');
+    const config = configManager.load();
+    const hasEnv = !!(process.env.GEMINI_KEY || process.env.GROQ_KEY);
+    if (hasEnv) {
+      console.log('\x1b[35m%s\x1b[0m', '🔑 Keys loaded from .env');
+    }
+    console.log('\x1b[36m%s\x1b[0m', 'Hotkeys:');
+    console.log(' - Ctrl+Shift+S: Capture & Solve');
+    console.log(' - Ctrl+Shift+M: Toggle Mouse (for scroll/copy)');
+    console.log(' - ` (Backtick): Panic Hide/Show');
+    console.log(' - Ctrl+Shift+X: Exit');
+  }
+});
+
+app.on('will-quit', () => {
+  globalShortcut.unregisterAll();
+});
+
+app.on('window-all-closed', () => {
+  app.quit();
+});
+
+// ─── Hotkeys ──────────────────────────────────────────────────────────────────
+
+function registerHotkeys() {
+  // Capture + solve (Ctrl+Shift+S)
+  globalShortcut.register('CommandOrControl+Shift+S', async () => {
+    console.log('\x1b[33m%s\x1b[0m', '📸 Capturing screen...');
+    overlayWindow.webContents.send('status', { type: 'loading', message: 'Solving...' });
+    await captureAndSolve();
+  });
+
+  // Panic hide/show (backtick ` — fastest single key)
+  // Hides the ENTIRE overlay window from screen share / prying eyes
+  let panicState = false;
+  globalShortcut.register('`', () => {
+    panicState = !panicState;
+    if (panicState) {
+      if (overlayWindow && overlayWindow.isVisible()) {
+        overlayWindow.webContents.send('panic', 'hide');
+        // Small delay so the renderer can process, then hide the window
+        setTimeout(() => { if (overlayWindow) overlayWindow.hide(); }, 80);
+      }
+    } else {
+      if (overlayWindow) {
+        overlayWindow.show();
+        overlayWindow.webContents.send('panic', 'show');
+      }
+    }
+  });
+
+  // Toggle just the answer text visibility (Ctrl+Shift+H)
+  globalShortcut.register('CommandOrControl+Shift+H', () => {
+    if (!overlayWindow) return;
+    overlayWindow.webContents.send('toggle-text');
+  });
+
+  // Clear answer (Ctrl+Shift+C)
+  globalShortcut.register('CommandOrControl+Shift+C', () => {
+    if (overlayWindow) overlayWindow.webContents.send('clear');
+  });
+
+  // Toggle Mouse Interaction (Ctrl+Shift+M)
+  let ignoreMouse = true;
+  globalShortcut.register('CommandOrControl+Shift+M', () => {
+    ignoreMouse = !ignoreMouse;
+    if (overlayWindow) {
+      overlayWindow.setIgnoreMouseEvents(ignoreMouse, { forward: true });
+      overlayWindow.webContents.send('status', { 
+        type: 'info', 
+        message: ignoreMouse ? 'Mouse: OFF' : 'Mouse: ON' 
+      });
+      console.log(`[Main] Mouse Ignore: ${ignoreMouse}`);
+    }
+  });
+
+  // SELF DESTRUCT / Finish Test (Ctrl+Shift+X)
+  // Instantly quits the app and unregisters all keys
+  globalShortcut.register('CommandOrControl+Shift+X', () => {
+    app.quit();
+  });
+}
+
+// ─── IPC Handlers ─────────────────────────────────────────────────────────────
+
+// Setup complete
+ipcMain.on('setup-complete', async (_, config) => {
+  configManager.save(config);
+  if (setupWindow) { setupWindow.close(); setupWindow = null; }
+  createOverlayWindow();
+  registerHotkeys();
+});
+
+// Get config
+ipcMain.handle('get-config', () => configManager.load());
+
+// Save config
+ipcMain.on('save-config', (_, config) => configManager.save(config));
+
+async function captureAndSolve() {
+  try {
+    const sources = await desktopCapturer.getSources({
+      types: ['screen'],
+      thumbnailSize: screen.getPrimaryDisplay().bounds
+    });
+
+    const source = sources[0];
+    const base64 = source.thumbnail.toDataURL();
+
+    if (overlayWindow) {
+      overlayWindow.show();
+      overlayWindow.setContentProtection(true);
+      overlayWindow.webContents.send('status', { type: 'loading', message: 'Thinking...' });
+    }
+
+    const config = configManager.load();
+    console.log('\x1b[33m%s\x1b[0m', '🧠 Thinking...');
+    const result = await solver.solve(base64, config);
+    console.log('\x1b[32m%s\x1b[0m', '✅ Result received!');
+
+    // ── Route based on question category ──────────────────────────────────────
+    if (result.type === 'web') {
+      // MERN / Web project → create folder on Desktop with all files
+      if (result.files && result.files.length > 0) {
+        const desktopPath = app.getPath('desktop');
+        const rawName = result.questionName || `WebProject_${Date.now()}`;
+        const folderName = rawName.replace(/[\\/:*?"<>|]/g, '_').trim() || `WebProject_${Date.now()}`;
+        const folderPath = path.join(desktopPath, folderName);
+
+        if (!fs.existsSync(folderPath)) {
+          fs.mkdirSync(folderPath, { recursive: true });
+        }
+
+        for (const file of result.files) {
+          if (file.name && file.content) {
+            const safeName = file.name.replace(/[\\/:*?"<>|]/g, '_');
+            // Support nested paths like "src/App.jsx"
+            const fullPath = path.join(folderPath, safeName);
+            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+            fs.writeFileSync(fullPath, file.content, 'utf8');
+          }
+        }
+      }
+    }
+    // DSA / MCQ / mixed → show on overlay screen (no folder needed)
+
+    if (overlayWindow) {
+      overlayWindow.webContents.send('answer', result);
+    }
+  } catch (err) {
+    if (overlayWindow) {
+      console.error('\x1b[31m%s\x1b[0m', `❌ Error: ${err.message}`);
+      overlayWindow.show();
+      overlayWindow.setContentProtection(true);
+      overlayWindow.webContents.send('status', { type: 'error', message: err.message });
+    }
+  }
+}
+
+// Window controls from renderer
+ipcMain.on('set-ignore-mouse', (event, ignore) => {
+  const win = BrowserWindow.fromWebContents(event.sender);
+  if (win) win.setIgnoreMouseEvents(ignore, { forward: true });
+});
+ipcMain.on('hide-window', () => { if (overlayWindow) overlayWindow.hide(); });
+ipcMain.on('quit-app', () => app.quit());

package/src/modelRotator.js

@@ -0,0 +1,94 @@
+/**
+ * Smart model rotation pool.
+ * Models are tried in priority order.
+ * When a model hits a rate limit, it enters a cooldown period
+ * and the next available model is used automatically.
+ */
+
+const MODEL_POOL = [
+  {
+    id: 'gemini-2.0-flash',
+    provider: 'gemini',
+    model: 'gemini-2.0-flash',
+    name: 'Gemini 2.0 Flash',
+    requiresKey: 'gemini'
+  },
+  {
+    id: 'gemini-1.5-flash',
+    provider: 'gemini',
+    model: 'gemini-1.5-flash',
+    name: 'Gemini 1.5 Flash',
+    requiresKey: 'gemini'
+  },
+  {
+    id: 'gemini-1.5-pro',
+    provider: 'gemini',
+    model: 'gemini-1.5-pro',
+    name: 'Gemini 1.5 Pro',
+    requiresKey: 'gemini'
+  },
+  {
+    id: 'groq-llama-4-scout',
+    provider: 'groq',
+    model: 'meta-llama/llama-4-scout-17b-16e-instruct',
+    name: 'Groq Llama 4 Scout',
+    requiresKey: 'groq'
+  },
+  {
+    id: 'gpt-4o-mini',
+    provider: 'openai',
+    model: 'gpt-4o-mini',
+    name: 'GPT-4o Mini',
+    requiresKey: 'openai'
+  }
+];
+
+// modelId -> timestamp until which it's cooling down
+const coolingModels = new Map();
+
+function getAvailableModels(keys) {
+  const now = Date.now();
+  return MODEL_POOL.filter((m) => {
+    if (!keys[m.requiresKey]) return false; // no API key configured
+    const coolUntil = coolingModels.get(m.id) || 0;
+    return now > coolUntil; // not cooling
+  });
+}
+
+function cooldown(modelId, seconds = 60) {
+  coolingModels.set(modelId, Date.now() + seconds * 1000);
+}
+
+function getNextModel(keys) {
+  const available = getAvailableModels(keys);
+  return available[0] || null;
+}
+
+function isRateLimitError(err) {
+  const msg = (err?.message || '').toLowerCase();
+  const status = err?.status || err?.statusCode || 0;
+  return (
+    status === 429 ||
+    msg.includes('rate limit') ||
+    msg.includes('quota') ||
+    msg.includes('resource exhausted') ||
+    msg.includes('too many requests')
+  );
+}
+
+function getModelStatus(keys) {
+  const now = Date.now();
+  return MODEL_POOL.map((m) => {
+    const hasKey = !!keys[m.requiresKey];
+    const coolUntil = coolingModels.get(m.id) || 0;
+    const cooling = now < coolUntil;
+    return {
+      ...m,
+      hasKey,
+      cooling,
+      coolRemaining: cooling ? Math.ceil((coolUntil - now) / 1000) : 0
+    };
+  });
+}
+
+module.exports = { MODEL_POOL, getNextModel, cooldown, isRateLimitError, getModelStatus };

package/src/panicManager.js

@@ -0,0 +1,46 @@
+const { BrowserWindow } = require('electron');
+
+let isPanicked = false;
+const hiddenState = new Map(); // windowId -> wasVisible
+
+function register(win) {
+  win.on('closed', () => hiddenState.delete(win.id));
+}
+
+function toggle() {
+  if (isPanicked) {
+    restore();
+  } else {
+    hide();
+  }
+}
+
+function hide() {
+  isPanicked = true;
+  hiddenState.clear();
+
+  BrowserWindow.getAllWindows().forEach((win) => {
+    hiddenState.set(win.id, win.isVisible());
+    if (win.isVisible()) {
+      win.hide();
+    }
+  });
+}
+
+function restore() {
+  isPanicked = false;
+
+  BrowserWindow.getAllWindows().forEach((win) => {
+    if (hiddenState.get(win.id)) {
+      win.show();
+    }
+  });
+
+  hiddenState.clear();
+}
+
+function isPanic() {
+  return isPanicked;
+}
+
+module.exports = { register, toggle, hide, restore, isPanic };

package/src/preload.js

@@ -0,0 +1,20 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('electronAPI', {
+  // Overlay receives
+  onAnswer:     (cb) => ipcRenderer.on('answer',      (_, data) => cb(data)),
+  onStatus:     (cb) => ipcRenderer.on('status',      (_, data) => cb(data)),
+  onClear:      (cb) => ipcRenderer.on('clear',       () => cb()),
+  onPanic:      (cb) => ipcRenderer.on('panic',       (_, state) => cb(state)),
+  onToggleText: (cb) => ipcRenderer.on('toggle-text', () => cb()),
+
+  // Setup
+  completeSetup: (config) => ipcRenderer.send('setup-complete', config),
+  getConfig:     ()       => ipcRenderer.invoke('get-config'),
+  saveConfig:    (config) => ipcRenderer.send('save-config', config),
+
+  // Window controls
+  setIgnoreMouse: (ignore) => ipcRenderer.send('set-ignore-mouse', ignore),
+  hideWindow: () => ipcRenderer.send('hide-window'),
+  quitApp:    () => ipcRenderer.send('quit-app')
+});

package/src/renderer/overlay/index.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Stealth Solver</title>
+  <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
+  <link rel="stylesheet" href="overlay.css" />
+</head>
+<body>
+
+  <!-- Tiny pulsing dot while loading (bottom-right) -->
+  <div id="loadingDot"></div>
+
+  <!-- Error dot (replaces loading dot on failure) -->
+  <div id="errorDot"></div>
+
+  <!-- Answer panel — MCQ text OR DSA code block, faint bottom-right -->
+  <div id="answerPanel">
+    <div id="answerLines"></div>
+  </div>
+
+  <!-- Short-lived saved notification for web/MERN questions -->
+  <div id="savedToast"></div>
+
+  <script src="overlay.js"></script>
+</body>
+</html>