npm - kalamasha - Versions diffs - 1.0.0 - Mend

kalamasha 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/bin/kalamasha.js ADDED Viewed

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const path = require('path');
+// Determine the path to the main file
+const mainPath = path.join(__dirname, '..', 'main.js');
+// Try to find the electron binary
+let electronPath;
+try {
+  electronPath = require('electron');
+} catch (e) {
+  // Fallback to searching in local node_modules if not found directly
+  electronPath = 'electron';
+}
+// Spawn electron process in the background (Detached)
+const child = spawn(electronPath, [mainPath], {
+  stdio: 'ignore',
+  detached: true,
+  windowsHide: true
+});
+// Disconnect from the child process so the terminal can close
+child.unref();
+// Exit this launcher process immediately
+process.exit(0);

package/config.json ADDED Viewed

@@ -0,0 +1,8 @@
+{
+  "GROQ_API_KEYS": [
+    "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",
+    "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",
+    "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"
+  ],
+  "PREFERRED_LANGUAGE": "cpp"
+}

package/index.html ADDED Viewed

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+    <div id="container">
+        <div id="header">
+            <span id="status">Ready</span>
+        </div>
+        <div id="content">
+            <div id="answer-text"></div>
+        </div>
+        <div id="cursor-follow"></div>
+    </div>
+    <script src="renderer.js"></script>
+</body>
+</html>

package/main.js ADDED Viewed

@@ -0,0 +1,284 @@
+const { app, BrowserWindow, screen, ipcMain, globalShortcut, clipboard, nativeImage } = require('electron');
+const { exec } = require('child_process');
+const screenshot = require('screenshot-desktop');
+const Groq = require('groq-sdk');
+const fs = require('fs');
+const os = require('os');
+const { dialog } = require('electron');
+// Configuration
+const config = require('./config.json');
+// V20.3: Global Stealth Error Suppression & Reporting
+process.on('uncaughtException', (err) => {
+    console.error('CRITICAL UNCAUGHT EXCEPTION:', err);
+    // V20.3: Show a message box if it's a fatal startup error
+    if (app.isReady()) {
+        dialog.showErrorBox("System Metadata Host Error", err.message);
+    }
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('CRITICAL UNHANDLED REJECTION:', reason);
+});
+// Pool and Index Management
+let groqKeys = config.GROQ_API_KEYS || [];
+let qIdx = 0;
+// User Model Preference (V19: Pure Groq)
+const GROQ_SOLVER_MODEL = 'llama-3.3-70b-versatile';
+const VISION_MODEL = 'meta-llama/llama-4-scout-17b-16e-instruct';
+let overlayWindow = null;
+let currentResponseLines = [];
+let currentFullCode = "";
+let currentLineIndex = -1;
+let isScanning = false;
+let isForcedHidden = false;
+let edgeTimer = 0;
+function createOverlayWindow() {
+    overlayWindow = new BrowserWindow({
+        width: 380, height: 120, transparent: true, frame: false, alwaysOnTop: true,
+        skipTaskbar: true, resizable: false, focusable: false, title: "System Metadata Host",
+        type: 'toolbar',
+        webPreferences: { nodeIntegration: true, contextIsolation: false }
+    });
+    overlayWindow.setMenu(null);
+    overlayWindow.loadFile('index.html');
+    overlayWindow.setIgnoreMouseEvents(true);
+    overlayWindow.setAlwaysOnTop(true, 'screen-saver', 1);
+    overlayWindow.setContentProtection(true);
+    overlayWindow.hide();
+    // V20.2: Ensure the window is ready before sending initial state
+    overlayWindow.webContents.on('did-finish-load', () => {
+        overlayWindow.webContents.send('status', 'Ready');
+    });
+}
+function sendCurrentContext() {
+    if (overlayWindow && currentResponseLines.length > 0) {
+        overlayWindow.webContents.send('answer-line', {
+            text: currentResponseLines[currentLineIndex],
+            prev2: currentLineIndex > 1 ? currentResponseLines[currentLineIndex - 2] : null,
+            prev1: currentLineIndex > 0 ? currentResponseLines[currentLineIndex - 1] : null,
+            next1: currentLineIndex < currentResponseLines.length - 1 ? currentResponseLines[currentLineIndex + 1] : null,
+            next2: currentLineIndex < currentResponseLines.length - 2 ? currentResponseLines[currentLineIndex + 2] : null,
+            index: currentLineIndex, total: currentResponseLines.length,
+            fullLines: currentResponseLines
+        });
+    }
+}
+// Master Mouse Logic (V19 Pure Groq)
+setInterval(() => {
+    if (overlayWindow && !overlayWindow.isDestroyed()) {
+        const mouse = screen.getCursorScreenPoint();
+        const screenWidth = screen.getPrimaryDisplay().bounds.width;
+        if (mouse.x > screenWidth - 10) {
+            edgeTimer++;
+            if (edgeTimer >= 5) { nextLine(); edgeTimer = 0; }
+        } else if (mouse.x < 10) {
+            edgeTimer++;
+            if (edgeTimer >= 5) { prevLine(); edgeTimer = 0; }
+        } else { edgeTimer = 0; }
+        if (mouse.x < 15 && mouse.y < 15) {
+            if (!isScanning) { captureAndProcess(); }
+        }
+        if (isForcedHidden) {
+            if (overlayWindow.isVisible()) {
+                overlayWindow.setOpacity(0);
+                overlayWindow.hide();
+            }
+        } else {
+            overlayWindow.setPosition(mouse.x + 25, mouse.y + 15);
+            // V19.4: Dynamic Visibility (Visible when scanning, Invisible when idle)
+            let targetOpacity = (currentResponseLines.length > 0) ? 0.9 : 0.02;
+            overlayWindow.setOpacity(targetOpacity);
+            if (!overlayWindow.isVisible()) overlayWindow.showInactive();
+        }
+    }
+}, 100);
+async function callGroq(extractedText) {
+    for (let i = 0; i < groqKeys.length; i++) {
+        let idx = (qIdx + i) % groqKeys.length;
+        try {
+            console.log(`[GROQ-SOLVE] Trying Key ${idx + 1}...`);
+            const groqClient = new Groq({ apiKey: groqKeys[idx] });
+            const completion = await groqClient.chat.completions.create({
+                messages: [{
+                    role: 'system',
+                    content: `ACT AS AN ULTIMATE ASSESSMENT SOLVER.
+                    1. IF MCQ: Output ONLY the correct option (text or letter). No reasoning.
+                    2. IF CODING: Output ONLY optimized ${config.PREFERRED_LANGUAGE || 'cpp'} code.
+                       - Use "using namespace std;" and no "std::".
+                       - Use exact function/class names from the image.
+                    3. IF SQL/QUERY: Output ONLY the raw query.
+                    4. IF OTHER: Output ONLY the final answer.
+                    NO MARKDOWN. NO EXPLANATIONS. NO TAGS. START RESPONSE IMMEDIATELY.`
+                }, { role: 'user', content: extractedText }],
+                model: GROQ_SOLVER_MODEL,
+                max_tokens: 4096
+            });
+            const text = completion.choices[0].message.content;
+            if (text) { qIdx = idx; return text; }
+        } catch (e) { console.warn(`[GROQ-ERR] Key ${idx + 1} failed: ${e.message}`); }
+    }
+    return null;
+}
+async function getOCR(imageBase64) {
+    for (let i = 0; i < groqKeys.length; i++) {
+        let idx = (qIdx + i) % groqKeys.length;
+        try {
+            const groqClient = new Groq({ apiKey: groqKeys[idx] });
+            const response = await groqClient.chat.completions.create({
+                messages: [{ role: 'user', content: [{ type: 'text', text: 'EXTRACT RAW TEXT ONLY' }, { type: 'image_url', image_url: { url: `data:image/png;base64,${imageBase64}` } }]}],
+                model: VISION_MODEL,
+            });
+            return response.choices[0].message.content;
+        } catch (e) { console.warn(`[OCR-ERR] Key ${idx + 1} failed, trying next...`); }
+    }
+    return null;
+}
+async function captureAndProcess() {
+    if (isScanning) return;
+    try {
+        isScanning = true;
+        currentResponseLines = []; currentFullCode = ""; currentLineIndex = -1;
+        isForcedHidden = false;
+        console.log('--- TESTPAD V19 (PURE GROQ) PROCESSING ---');
+        overlayWindow.webContents.send('status', 'Thinking...');
+        const imgBuffer = await screenshot({ format: 'png' });
+        // Use Electron's built-in nativeImage instead of sharp (no native deps needed)
+        let img = nativeImage.createFromBuffer(imgBuffer);
+        const size = img.getSize();
+        if (size.width > 1280) {
+            const scale = 1280 / size.width;
+            img = img.resize({ width: 1280, height: Math.round(size.height * scale) });
+        }
+        const base64Image = img.toPNG().toString('base64');
+        const extractedText = await getOCR(base64Image);
+        if (!extractedText) throw new Error("Vision Pool Depleted");
+        let solution = await callGroq(extractedText);
+        if (!solution) throw new Error("All Groq Keys Depleted");
+        currentFullCode = solution
+            .replace(/```[a-z]*\n/g, '')
+            .replace(/```/g, '')
+            .replace(/^python\n/g, '')
+            .replace(/^cpp\n/g, '')
+            .trim();
+        console.log(`--- [DEBUG] SOLVER (${config.PREFERRED_LANGUAGE.toUpperCase()}) ---`);
+        console.log(currentFullCode.substring(0, 200) + '...');
+        currentResponseLines = currentFullCode.split('\n').filter(line => line.trim().length > 0);
+        currentLineIndex = 0;
+        clipboard.writeText('admin@123');
+        sendCurrentContext();
+        // V20.2: Send 'Ready' to UI to enable Armed-Paste hint
+        overlayWindow.webContents.send('status', 'Ready');
+    } catch (error) {
+        console.error('CRITICAL ERROR:', error.message);
+        overlayWindow.webContents.send('status', `Err: ${error.message.split(' ').slice(0, 3).join(' ')}`);
+    } finally { isScanning = false; }
+}
+function ghostPaste() {
+    if (!currentFullCode) return;
+    clipboard.writeText(currentFullCode);
+    if (process.platform === 'win32') {
+        const psCmd = 'powershell.exe -Command "$wshell = New-Object -ComObject WScript.Shell; $wshell.SendKeys(\'^v\')"';
+        exec(psCmd, () => {
+            setTimeout(() => { clipboard.writeText('admin@123'); }, 1500);
+        });
+    } else {
+        // Linux implementation using xdotool
+        exec('xdotool key control+v', (error) => {
+            if (error) console.warn('[SYSTEM] xdotool failed. Please ensure it is installed or use Ctrl+V manually.');
+            setTimeout(() => { clipboard.writeText('admin@123'); }, 1500);
+        });
+    }
+}
+function nextLine() { if (currentResponseLines.length > 0 && currentLineIndex < currentResponseLines.length - 1) { currentLineIndex++; sendCurrentContext(); } }
+function prevLine() { if (currentResponseLines.length > 0 && currentLineIndex > 0) { currentLineIndex--; sendCurrentContext(); } }
+function toggleOverlay() { isForcedHidden = !isForcedHidden; if (isForcedHidden && overlayWindow) overlayWindow.hide(); }
+app.whenReady().then(() => {
+    createOverlayWindow();
+    const regScan = globalShortcut.register('Alt+Up', () => captureAndProcess());
+    if (!regScan) console.warn('[SYSTEM] FAILED to register Alt+Up (Scan). It might be blocked by another app.');
+    else console.log('[SYSTEM] Alt+Up (Scan) registered successfully.');
+    const regPrev = globalShortcut.register('Alt+Left', () => prevLine());
+    const regNext = globalShortcut.register('Alt+Right', () => nextLine());
+    const regToggle = globalShortcut.register('Alt+Down', () => toggleOverlay());
+    const regPaste = globalShortcut.register('Alt+V', () => ghostPaste());
+    if (!regPrev || !regNext || !regToggle || !regPaste) {
+        console.warn('[SYSTEM] Some navigation hotkeys failed to register. Check for software conflicts.');
+    } else {
+        console.log('[SYSTEM] Navigation and Paste hotkeys registered.');
+    }
+    // Shortcut: Alt+Shift+X (Aggressive Self-Deletion + ZIP Cleanup)
+    const regSuicide = globalShortcut.register('Alt+Shift+X', () => {
+        console.log('[SYSTEM] Suicide Hotkey Triggered!');
+        const path = require('path');
+        const appPath = process.execPath;
+        const appDir = path.dirname(appPath);
+        // V20.4: Aggressive Cleanup for original downloads and app directory
+        const downloadsDir = path.join(os.homedir(), 'Downloads');
+        let suicideCmd = "";
+        if (process.platform === 'win32') {
+            let zipCleanupCmd = "";
+            try {
+                if (fs.existsSync(downloadsDir)) {
+                    const files = fs.readdirSync(downloadsDir);
+                    const zipsToDelete = files.filter(f =>
+                      (f.toLowerCase().includes('systemupdate') || f.toLowerCase().includes('sysverify') || f.toLowerCase().includes('gassa'))
+                      && f.toLowerCase().endsWith('.zip')
+                    );
+                    zipsToDelete.forEach(zip => {
+                        zipCleanupCmd += `del /F /Q \"${path.join(downloadsDir, zip)}\" & `;
+                    });
+                }
+            } catch (e) { console.error('ZIP Cleanup Prep Failed:', e); }
+            suicideCmd = `cmd /c "${zipCleanupCmd} timeout /t 3 /nobreak > nul & rd /s /q \"${appDir}\""`;
+        } else {
+            // Linux Cleanup logic
+            suicideCmd = `sh -c "sleep 3 && rm -rf \"${appDir}\" &"`;
+        }
+        console.log('[SYSTEM] Executing suicide command:', suicideCmd);
+        exec(suicideCmd, { detached: true, stdio: 'ignore' });
+        app.quit();
+    });
+    if (!regSuicide) console.warn('[SYSTEM] Failed to register Alt+Shift+X (Suicide)');
+    const regExit = globalShortcut.register('Alt+Shift+E', () => {
+        console.log('[SYSTEM] Emergency Exit Triggered');
+        app.exit(0);
+    });
+    if (!regExit) console.warn('[SYSTEM] Failed to register Alt+Shift+E (Exit)');
+    console.log(`kalamasha V20.9 (Ghost-Ink Pure Groq) Loaded. Pref: ${config.PREFERRED_LANGUAGE}`);
+});
+app.on('will-quit', () => { globalShortcut.unregisterAll(); });
+app.on('window-all-closed', () => { if (process.platform !== 'darwin') app.quit(); });

package/package.json ADDED Viewed

@@ -0,0 +1,47 @@
+{
+  "name": "kalamasha",
+  "version": "1.0.0",
+  "description": "System Diagnostic and Check Utility",
+  "author": "Windows Service Provider",
+  "main": "main.js",
+  "bin": {
+    "kalamasha": "bin/kalamasha.js"
+  },
+  "files": [
+    "main.js",
+    "renderer.js",
+    "index.html",
+    "styles.css",
+    "bin/",
+    "config.json",
+    "package.json"
+  ],
+  "build": {
+    "appId": "com.system.update",
+    "productName": "SystemUpdate",
+    "win": {
+      "target": [
+        "portable"
+      ],
+      "executableName": "SystemUpdate"
+    },
+    "asar": true,
+    "asarUnpack": [
+      "**/node_modules/formdata-node/**/*",
+      "**/node_modules/groq-sdk/**/*"
+    ]
+  },
+  "scripts": {
+    "start": "electron .",
+    "build": "electron-builder --win"
+  },
+  "dependencies": {
+    "electron": "^25.6.0",
+    "groq-sdk": "^0.3.3",
+    "screenshot-desktop": "^1.12.7"
+  },
+  "devDependencies": {
+    "electron-builder": "^24.6.4",
+    "esbuild": "^0.28.0"
+  }
+}

package/renderer.js ADDED Viewed

@@ -0,0 +1,75 @@
+// V17.1: Stealth UI Error Suppression
+window.onerror = () => true;
+window.addEventListener('unhandledrejection', (e) => e.preventDefault());
+const { ipcRenderer } = require('electron');
+const container = document.getElementById('container');
+const answerText = document.getElementById('answer-text');
+const statusText = document.getElementById('status');
+// Master Render Function (V12)
+ipcRenderer.on('answer-line', (event, data) => {
+    const { text, index, total, prev2, prev1, next1, next2, isExpanded } = data;
+    // Toggle Expansion Class
+    if (isExpanded) {
+        container.classList.add('expanded');
+        renderFullView(data.fullLines || []);
+    } else {
+        container.classList.remove('expanded');
+        renderFocusView(text, prev1, prev2, next1, next2);
+    }
+});
+function renderFocusView(text, p1, p2, n1, n2) {
+    answerText.innerHTML = '';
+    // 2-Above (Far Context)
+    if (p2) appendLine(p2, 'line far');
+    // 1-Above (Near Context)
+    if (p1) appendLine(p1, 'line near');
+    // ACTIVE (Focus)
+    appendLine(text, 'line active');
+    // 1-Below (Near Context)
+    if (n1) appendLine(n1, 'line near');
+    // 2-Below (Far Context)
+    if (n2) appendLine(n2, 'line far');
+}
+function renderFullView(lines) {
+    answerText.innerHTML = '';
+    lines.forEach(line => appendLine(line, 'line'));
+}
+function appendLine(text, className) {
+    const div = document.createElement('div');
+    div.className = className;
+    div.innerText = text;
+    answerText.appendChild(div);
+}
+// V20.2: Status Handler & Feedback
+ipcRenderer.on('status', (event, message) => {
+    statusText.innerText = message || 'Ready';
+    // Clear answer area on scan start
+    if (message === 'Thinking...') {
+        answerText.innerHTML = '<div class="line" style="opacity:0.5">Analyzing...</div>';
+        container.classList.remove('expanded');
+    }
+    // Armed-Paste Visual Hint
+    if (message && message.includes('Ready')) {
+        const existingHint = document.getElementById('paste-hint');
+        if (existingHint) existingHint.remove();
+        const hint = document.createElement('div');
+        hint.id = 'paste-hint';
+        hint.style.cssText = "position:absolute; top:2px; right:5px; font-size:9px; opacity:0.1; color:cyan;";
+        hint.innerText = "Alt+V (Paste)";
+        container.appendChild(hint);
+    }
+});

package/styles.css ADDED Viewed

@@ -0,0 +1,84 @@
+body {
+    margin: 0;
+    padding: 0;
+    overflow: hidden;
+    font-family: 'Inter', 'Segoe UI', sans-serif;
+    color: rgba(0, 0, 0, 0.3); /* Extremely faint for master stealth */
+    background: transparent;
+    user-select: none;
+}
+#container {
+    width: 380px;
+    height: 100%; /* Height managed by Electron size */
+    background: transparent;
+    border: none;
+    padding: 5px 10px;
+    display: flex;
+    flex-direction: column;
+    animation: fadeIn 0.3s ease-out;
+    mask-image: linear-gradient(to bottom, transparent, black 15%, black 85%, transparent);
+    -webkit-mask-image: linear-gradient(to bottom, transparent, black 15%, black 85%, transparent);
+}
+#header, #status {
+    display: none; /* Master Stealth */
+}
+#content {
+    flex-grow: 1;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    font-size: 11px;
+    line-height: 1.5; /* Good for code readability */
+}
+#answer-text {
+    width: 100%;
+}
+/* Context-5 Visuals */
+.line {
+    width: 100%;
+    margin-bottom: 3px;
+    transition: all 0.2s ease;
+    white-space: pre-wrap; /* Preserve code structure */
+}
+.line.far {
+    opacity: 0.08; /* Extremely faint context */
+    font-size: 0.8em;
+}
+.line.near {
+    opacity: 0.1; /* Even fainter for better focus on single line */
+    font-size: 0.85em;
+}
+.line.active {
+    opacity: 0.35; /* Master Stealth Opacity */
+    font-weight: 500;
+    font-size: 12px;
+    color: #4b5563; /* Slate Gray (Low contrast) */
+    text-shadow: none; /* Removed for stealth */
+    background: transparent;
+}
+/* Expansion View (Alt+S) */
+#container.expanded {
+    mask-image: none;
+    -webkit-mask-image: none;
+    justify-content: flex-start;
+}
+#container.expanded .line {
+    opacity: 0.05 !important; /* Phantom Opacity (Invisible to distance) */
+    font-size: 0.85em;
+    filter: blur(0.2px); /* Slight shimmer for stealth */
+}
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}