@myth-tools/myth 0.1.0

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@myth-tools/myth",
+  "version": "0.1.0",
+  "description": "An ultra-fast AI-powered reconnaissance agent for Kali Linux",
+  "main": "run.js",
+  "bin": {
+    "myth": "run.js",
+    "myth-cli": "run.js"
+  },
+  "scripts": {
+    "postinstall": "node provision-browser.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/myth-tools/MYTH-CLI.git"
+  },
+  "bugs": {
+    "url": "https://github.com/myth-tools/MYTH-CLI/issues"
+  },
+  "homepage": "https://myth.work.gd",
+  "funding": "https://github.com/sponsors/myth-tools",
+  "files": [
+    "run.js"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "keywords": [
+    "kali",
+    "reconnaissance",
+    "ai",
+    "agent",
+    "security",
+    "osint",
+    "cli"
+  ],
+  "author": "myth-tools <shesher0llms@gmail.com>",
+  "creator": {
+    "name": "Shesher Hasan",
+    "role": "Chief Architect",
+    "contact": "shesher0llms@gmail.com",
+    "organization": "myth-tools",
+    "clearance_level": "OPERATIVE-LEVEL-4 (SENIOR ARCHITECT)",
+    "system_license": "MYTH-INSTITUTIONAL-COMMERCIAL-2026-BETA"
+  },
+  "license": "MIT"
+}

package/run.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * MYTH CLI — Native Execution Link (Node.js Proxy)
+ * 
+ * This advanced interceptor allows the MYTH neural core to be deployed dynamically 
+ * via `npx` without sacrificing the strict, system-level sandboxing (Bubblewrap) 
+ * required for offensive security operations.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+// Stylized output handlers respecting TTY
+const isTTY = process.stdout.isTTY;
+const format = {
+    red: (str) => isTTY ? `\x1b[31m${str}\x1b[0m` : str,
+    green: (str) => isTTY ? `\x1b[32m${str}\x1b[0m` : str,
+    yellow: (str) => isTTY ? `\x1b[33m${str}\x1b[0m` : str,
+    cyan: (str) => isTTY ? `\x1b[36m${str}\x1b[0m` : str,
+    bold: (str) => isTTY ? `\x1b[1m${str}\x1b[0m` : str,
+    dim: (str) => isTTY ? `\x1b[2m${str}\x1b[0m` : str,
+};
+
+// ─── 0. System Constraint Validation ───
+if (os.platform() !== 'linux') {
+    console.error(format.red(format.bold(`✘ [FATAL ARCHITECTURE ERROR]`)));
+    console.error(format.red(`MYTH is a highly specialized offensive security operative.`));
+    console.error(format.yellow(`It enforces strict sandboxing via Linux user namespaces (Bubblewrap).`));
+    console.error(`Current OS: ${os.platform()} is NOT supported. Deploy on Kali Linux or Ubuntu.\n`);
+    process.exit(1);
+}
+
+/**
+ * Perform a robust resolution of the NATIVE neural core binary.
+ * This filters out Node.js symlinks to prevent infinite proxy loops.
+ * @param {string} cmd Binary to locate
+ * @returns {string|null} Resolved path or null
+ */
+const getCommandPath = (cmd) => {
+    try {
+        // FAST-PATH: Probe standard tactical locations directly (Zero-Latency)
+        const fastPaths = ['/usr/bin/myth', '/usr/local/bin/myth'];
+        for (const fp of fastPaths) {
+            if (fs.existsSync(fp)) {
+                const stats = fs.statSync(fp);
+                if (stats.isFile()) return fp;
+            }
+        }
+
+        // FALLBACK: Find all occurrences of the command in PATH
+        const output = require('child_process')
+            .execSync(`whereis -b ${cmd} | cut -d: -f2`, { stdio: 'pipe' })
+            .toString()
+            .trim();
+        
+        const paths = output.split(/\s+/).filter(p => !!p);
+        
+        for (const p of paths) {
+            // A professional native install typically sits in /usr/bin or /usr/local/bin
+            // We ignore any path that looks like an npm/nvm/bun/node directory
+            const isNodeScript = p.includes('node_modules') || 
+                               p.includes('.npm') || 
+                               p.includes('.nvm') || 
+                               p.includes('.bun');
+                               
+            if (!isNodeScript && fs.existsSync(p)) {
+                // Ensure it's not a directory and is a real binary
+                const stats = fs.statSync(p);
+                if (stats.isFile()) return p;
+            }
+        }
+        return null;
+    } catch {
+        return null;
+    }
+};
+
+/**
+ * ─── 1. Core Deployment Orchestrator ───
+ * Elevates privileges securely and invokes the native bash implementation.
+ */
+async function executeDeployment() {
+    console.log(`\n` + format.cyan(format.bold(`⚡ TACTICAL PROXY: MYTH Neural Core Offline`)));
+    console.log(format.dim(`MYTH operates complex Linux sandboxes and requires host-level dependencies (Bubblewrap, Nmap, Tor).\nTo orchestrate these tools autonomously, we must first arm your environment natively.`));
+    console.log(format.yellow(`\n⚠  SECURITY NOTICE: You will securely be prompted for your 'sudo' password.`));
+    console.log(format.dim(`   Executing: 'curl -fsSL https://myth.work.gd/install.sh | sudo bash'\n`));
+
+    return new Promise((resolve, reject) => {
+        // Spawn remote bash installer directly with strict pipefail catching
+        const proc = spawn('bash', ['-c', 'set -euo pipefail; curl -fsSL https://myth.work.gd/install.sh | sudo bash'], { 
+            stdio: 'inherit'
+        });
+
+        proc.on('error', (err) => {
+            console.error(format.red(`\n✘ [SPAWN ERROR] Failed to initialize deployment: ${err.message}`));
+            reject(err);
+        });
+
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                console.error(format.red(format.bold(`\n✘ [DEPLOYMENT FAILED] System configuration aborted.`)));
+                process.exit(code || 1);
+            }
+            resolve();
+        });
+    });
+}
+
+/**
+ * ─── 2. Transparent Telemetry Forwarder ───
+ * Binds standard I/O and propagates OS-level signals identically to a native run.
+ */
+async function forwardTelemetry(binaryPath, args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(binaryPath, args, {
+            stdio: 'inherit',
+            env: process.env
+        });
+
+        proc.on('error', (err) => {
+            console.error(format.red(`\n✘ [CORE CRASH] Failed to invoke neural core: ${err.message}`));
+            reject(err);
+        });
+
+        // Industry-Grade Signal Propagation
+        // Safely pass Ctrl+C, TERM, and system interrupts down to the Rust core
+        const signals = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT', 'SIGUSR1', 'SIGUSR2'];
+        signals.forEach((signal) => {
+            process.on(signal, () => {
+                if (proc && !proc.killed) {
+                    proc.kill(signal);
+                }
+            });
+        });
+
+        proc.on('close', (code) => {
+            resolve(code || 0);
+        });
+    });
+}
+
+// ─── Phase Zero: Entry Point Orchestration ───
+(async () => {
+    try {
+        const rawArgs = process.argv.slice(2);
+        const finalArgs = rawArgs.length === 0 ? ['chat'] : rawArgs;
+        
+        let mythPath = getCommandPath('myth');
+
+        // Bootstrap logic - Only show headers/logs if we are actually installing
+        if (!mythPath) {
+            await executeDeployment();
+            
+            mythPath = getCommandPath('myth');
+            if (!mythPath) {
+                console.error(format.red(format.bold(`\n✘ [FATAL] MYTH footprint vanished. PATH resolution failed after successful install.`)));
+                console.error(format.yellow(`Try reloading your shell: "source ~/.bashrc" and execute again.`));
+                process.exit(1);
+            }
+            
+            console.log(format.green(format.bold(`\n✔ MYTH NEURAL CORE SYNCHRONIZED.`)));
+            console.log(format.dim(`The 'myth' command is now natively available on your system.\n`));
+        }
+
+        // Forward raw telemetry or default to 'chat' mission
+        // Handover is silent and transparent
+        const code = await forwardTelemetry(mythPath, finalArgs);
+        process.exit(code);
+    } catch (e) {
+        console.error(format.red(`\n✘ [PROXY FAILURE] An unrecoverable exception occurred in the Node interceptor.`));
+        console.error(format.dim(e.stack));
+        process.exit(1);
+    }
+})();