gitxelectron 1.3.7 → 1.3.8

package/bin/auto-push.js

@@ -0,0 +1,526 @@
+#!/usr/bin/env node
+
+/**
+ * GitQuickPush / GitElectron Auto-Push & Big File Splitting Engine
+ *
+ * Features:
+ * - Safety guards (prevents accidental staging of system root / home dir)
+ * - Secret protection (blocks .env, private keys, certificates, credentials)
+ * - Git LFS auto-configuration for AI/ML file formats
+ * - Big file detector (>95MB) with ultra-fast streaming chunking & live progress
+ * - Companion 1-click reassembly (auto-restore) with SHA-256 verification
+ * - High-speed Git push with live transfer progress & network buffering
+ */
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const { spawnSync, spawn } = require('child_process')
+
+const CHUNK_SIZE_BYTES = 45 * 1024 * 1024 // 45 MB chunks (safely under GitHub's 100MB limit)
+const BIG_FILE_THRESHOLD = 95 * 1024 * 1024 // 95 MB trigger threshold
+
+const SENSITIVE_PATTERNS = [
+  /^\.env(\..+)?$/i,
+  /\.pem$/i,
+  /\.key$/i,
+  /\.pkcs12$/i,
+  /\.pfx$/i,
+  /\.p12$/i,
+  /^id_rsa(\..+)?$/i,
+  /^id_ed25519(\..+)?$/i,
+  /^id_ecdsa(\..+)?$/i,
+  /credentials\.json$/i,
+  /service-account.*\.json$/i
+]
+
+const AIML_EXTENSIONS = [
+  '*.csv',
+  '*.jsonl',
+  '*.parquet',
+  '*.zip',
+  '*.tar',
+  '*.pt',
+  '*.pth',
+  '*.onnx',
+  '*.h5',
+  '*.pkl',
+  '*.joblib',
+  '*.bin'
+]
+
+// Terminal styling helpers
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  gray: '\x1b[90m'
+}
+
+function log(msg, color = colors.reset) {
+  console.log(`${color}${msg}${colors.reset}`)
+}
+
+function runGit(args, options = {}) {
+  const result = spawnSync('git', args, {
+    cwd: options.cwd || process.cwd(),
+    encoding: 'utf-8',
+    stdio: options.stdio || 'pipe',
+    shell: false
+  })
+  return result
+}
+
+function runGitLive(args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn('git', args, {
+      cwd: options.cwd || process.cwd(),
+      stdio: 'inherit',
+      shell: false
+    })
+    child.on('close', (code) => resolve(code))
+    child.on('error', (err) => {
+      log(`Git execution error: ${err.message}`, colors.red)
+      resolve(1)
+    })
+  })
+}
+
+// Check directory safety
+function verifySafety(cwd) {
+  const normalized = path.resolve(cwd)
+  const home = path.resolve(process.env.HOME || process.env.USERPROFILE || '')
+  const root = path.parse(normalized).root
+
+  if (normalized === root) {
+    log('❌ SAFETY BLOCK: Running auto-push in the system drive root is blocked.', colors.red)
+    log('Run this script inside your specific project directory.', colors.yellow)
+    process.exit(1)
+  }
+
+  if (home && normalized === home) {
+    log(
+      '❌ SAFETY BLOCK: Running auto-push directly in your User Home directory is blocked.',
+      colors.red
+    )
+    log(
+      'This prevents accidental upload of SSH keys, browser data, and private files.',
+      colors.yellow
+    )
+    process.exit(1)
+  }
+}
+
+// Configure Git LFS and .gitattributes
+function configureGitLfs(cwd) {
+  const gitattrPath = path.join(cwd, '.gitattributes')
+  let currentContent = ''
+  if (fs.existsSync(gitattrPath)) {
+    try {
+      currentContent = fs.readFileSync(gitattrPath, 'utf-8')
+    } catch {}
+  }
+
+  const missingRules = []
+  for (const ext of AIML_EXTENSIONS) {
+    const rule = `${ext} filter=lfs diff=lfs merge=lfs -text`
+    if (!currentContent.includes(ext)) {
+      missingRules.push(rule)
+    }
+  }
+
+  if (missingRules.length > 0) {
+    log(`📦 Updating .gitattributes with Git LFS rules for AI/ML formats...`, colors.cyan)
+    const newContent =
+      (currentContent ? currentContent.trim() + '\n' : '') +
+      '# Git LFS tracking for AI/ML and large binary assets\n' +
+      missingRules.join('\n') +
+      '\n'
+    fs.writeFileSync(gitattrPath, newContent, 'utf-8')
+  }
+
+  // Ensure git lfs install is invoked
+  runGit(['lfs', 'install'], { cwd })
+}
+
+// Scan for sensitive files
+function scanSecrets(cwd) {
+  const gitStatus = runGit(['status', '--porcelain', '-uall'], { cwd })
+  if (gitStatus.status !== 0) return
+
+  const lines = gitStatus.stdout.split('\n')
+  const detected = []
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    const filePath = trimmed.substring(3).trim().replace(/^"|"$/g, '')
+    const baseName = path.basename(filePath)
+
+    if (baseName === '.env.example' || baseName === '.env.template') continue
+
+    for (const pat of SENSITIVE_PATTERNS) {
+      if (pat.test(baseName)) {
+        detected.push(filePath)
+        break
+      }
+    }
+  }
+
+  if (detected.length > 0) {
+    log('\n⚠️  SECURITY WARNING: Potential sensitive files detected:', colors.yellow)
+    for (const file of detected) {
+      log(`   ⛔ ${file}`, colors.red)
+    }
+    log('Secrets should never be committed to Git repositories.', colors.yellow)
+    log('Adding sensitive files to .git/info/exclude to prevent leak...', colors.cyan)
+
+    const excludePath = path.join(cwd, '.git', 'info', 'exclude')
+    try {
+      fs.mkdirSync(path.dirname(excludePath), { recursive: true })
+      let excludeContent = fs.existsSync(excludePath) ? fs.readFileSync(excludePath, 'utf-8') : ''
+      for (const file of detected) {
+        if (!excludeContent.includes(file)) {
+          excludeContent += `\n${file}`
+        }
+      }
+      fs.writeFileSync(excludePath, excludeContent, 'utf-8')
+      runGit(['reset', 'HEAD', ...detected], { cwd })
+      log('✅ Excluded sensitive files safely.', colors.green)
+    } catch (e) {
+      log(`Failed to update exclude: ${e.message}`, colors.red)
+    }
+  }
+}
+
+// Format bytes
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B'
+  const k = 1024
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
+  const i = Math.floor(Math.log(bytes) / Math.log(k))
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+}
+
+// Split a large file with streaming and live status
+async function splitLargeFile(filePath, cwd) {
+  const stat = fs.statSync(filePath)
+  const totalSize = stat.size
+  const relPath = path.relative(cwd, filePath).replace(/\\/g, '/')
+  const totalChunks = Math.ceil(totalSize / CHUNK_SIZE_BYTES)
+
+  log(`\n⚡ [BIG FILE DETECTED] ${relPath} (${formatBytes(totalSize)})`, colors.yellow)
+  log(`   Splitting into ${totalChunks} parts (each ≤ 45 MB) with live status...`, colors.cyan)
+
+  const hash = crypto.createHash('sha256')
+  const manifest = {
+    originalFile: relPath,
+    fileSize: totalSize,
+    sha256: '',
+    chunkSize: CHUNK_SIZE_BYTES,
+    totalChunks,
+    chunks: [],
+    splitTimestamp: new Date().toISOString()
+  }
+
+  const readStream = fs.createReadStream(filePath, { highWaterMark: 4 * 1024 * 1024 })
+  let currentChunkIndex = 0
+  let currentChunkBytes = 0
+  let currentChunkPath = `${filePath}.part${String(currentChunkIndex).padStart(2, '0')}`
+  let currentWriteStream = fs.createWriteStream(currentChunkPath)
+  manifest.chunks.push(path.basename(currentChunkPath))
+
+  let processedBytes = 0
+  const startTime = Date.now()
+
+  return new Promise((resolve, reject) => {
+    readStream.on('data', (buffer) => {
+      hash.update(buffer)
+      let offset = 0
+
+      while (offset < buffer.length) {
+        const remainingInChunk = CHUNK_SIZE_BYTES - currentChunkBytes
+        const toWrite = Math.min(buffer.length - offset, remainingInChunk)
+
+        currentWriteStream.write(buffer.slice(offset, offset + toWrite))
+        currentChunkBytes += toWrite
+        offset += toWrite
+        processedBytes += toWrite
+
+        // Render live progress
+        const percent = Math.min(100, Math.floor((processedBytes / totalSize) * 100))
+        const elapsedSec = (Date.now() - startTime) / 1000
+        const speedMBs =
+          elapsedSec > 0 ? (processedBytes / (1024 * 1024) / elapsedSec).toFixed(1) : '0'
+        const barWidth = 25
+        const filled = Math.floor((percent / 100) * barWidth)
+        const bar =
+          '='.repeat(filled) +
+          (filled < barWidth ? '>' : '') +
+          ' '.repeat(Math.max(0, barWidth - filled - 1))
+        process.stdout.write(
+          `\r   [${bar}] ${percent}% | ${formatBytes(processedBytes)} / ${formatBytes(totalSize)} | ${speedMBs} MB/s`
+        )
+
+        if (currentChunkBytes >= CHUNK_SIZE_BYTES && processedBytes < totalSize) {
+          currentWriteStream.end()
+          currentChunkIndex++
+          currentChunkBytes = 0
+          currentChunkPath = `${filePath}.part${String(currentChunkIndex).padStart(2, '0')}`
+          currentWriteStream = fs.createWriteStream(currentChunkPath)
+          manifest.chunks.push(path.basename(currentChunkPath))
+        }
+      }
+    })
+
+    readStream.on('end', () => {
+      currentWriteStream.end(() => {
+        manifest.sha256 = hash.digest('hex')
+        process.stdout.write('\n')
+
+        // Write manifest
+        const manifestPath = `${filePath}.split-manifest.json`
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8')
+
+        // Exclude the original big file from git so only chunks & manifest are tracked
+        const excludePath = path.join(cwd, '.git', 'info', 'exclude')
+        try {
+          fs.mkdirSync(path.dirname(excludePath), { recursive: true })
+          let excludeContent = fs.existsSync(excludePath)
+            ? fs.readFileSync(excludePath, 'utf-8')
+            : ''
+          if (!excludeContent.includes(relPath)) {
+            excludeContent += `\n${relPath}\n`
+            fs.writeFileSync(excludePath, excludeContent, 'utf-8')
+          }
+          // Untrack original if it was previously staged
+          runGit(['rm', '--cached', '-f', relPath], { cwd })
+        } catch {}
+
+        log(
+          `   ✅ Finished splitting: ${manifest.chunks.length} parts created. SHA-256: ${manifest.sha256.substring(0, 16)}...`,
+          colors.green
+        )
+        resolve()
+      })
+    })
+
+    readStream.on('error', reject)
+  })
+}
+
+// Find files exceeding BIG_FILE_THRESHOLD
+function findBigFiles(dir, cwd, list = []) {
+  const ignoredDirs = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'out',
+    'build',
+    '.venv',
+    'venv',
+    '__pycache__',
+    'target'
+  ])
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (ignoredDirs.has(entry.name)) continue
+      findBigFiles(path.join(dir, entry.name), cwd, list)
+    } else if (entry.isFile()) {
+      if (entry.name.includes('.part') || entry.name.endsWith('.split-manifest.json')) continue
+      const fullPath = path.join(dir, entry.name)
+      try {
+        const stat = fs.statSync(fullPath)
+        if (stat.size >= BIG_FILE_THRESHOLD) {
+          list.push(fullPath)
+        }
+      } catch {}
+    }
+  }
+  return list
+}
+
+// Restore all split files in the workspace
+async function restoreAllSplitFiles(cwd) {
+  log('\n🔍 Scanning for split file manifests...', colors.cyan)
+  const manifests = []
+
+  function findManifests(dir) {
+    const ignoredDirs = new Set(['.git', 'node_modules', 'dist', 'out', 'build', '.venv', 'venv'])
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (ignoredDirs.has(entry.name)) continue
+        findManifests(path.join(dir, entry.name))
+      } else if (entry.isFile() && entry.name.endsWith('.split-manifest.json')) {
+        manifests.push(path.join(dir, entry.name))
+      }
+    }
+  }
+
+  findManifests(cwd)
+
+  if (manifests.length === 0) {
+    log('No split manifests found. All files are intact!', colors.green)
+    return
+  }
+
+  log(`Found ${manifests.length} split file manifest(s). Starting reassembly...`, colors.yellow)
+
+  for (const mPath of manifests) {
+    const manifest = JSON.parse(fs.readFileSync(mPath, 'utf-8'))
+    const dir = path.dirname(mPath)
+    const targetFile = path.join(cwd, manifest.originalFile)
+
+    log(
+      `\nReassembling: ${manifest.originalFile} (${formatBytes(manifest.fileSize)})...`,
+      colors.cyan
+    )
+    const writeStream = fs.createWriteStream(targetFile)
+    const hash = crypto.createHash('sha256')
+
+    for (let i = 0; i < manifest.chunks.length; i++) {
+      const chunkName = manifest.chunks[i]
+      const chunkPath = path.join(dir, chunkName)
+      if (!fs.existsSync(chunkPath)) {
+        log(`❌ Error: Chunk ${chunkName} is missing!`, colors.red)
+        writeStream.end()
+        return
+      }
+
+      const chunkBuffer = fs.readFileSync(chunkPath)
+      hash.update(chunkBuffer)
+      writeStream.write(chunkBuffer)
+      process.stdout.write(`\r   Reassembling part ${i + 1}/${manifest.chunks.length}...`)
+    }
+
+    await new Promise((res) => writeStream.end(res))
+    process.stdout.write('\n')
+
+    const computedHash = hash.digest('hex')
+    if (computedHash === manifest.sha256) {
+      log(`✅ Integrity verified! SHA-256 matches.`, colors.green)
+    } else {
+      log(`⚠️ Warning: Checksum mismatch for ${manifest.originalFile}!`, colors.red)
+    }
+  }
+}
+
+// Main auto-push routine
+async function main() {
+  const cwd = process.cwd()
+  verifySafety(cwd)
+
+  const args = process.argv.slice(2)
+  if (args.includes('restore')) {
+    await restoreAllSplitFiles(cwd)
+    return
+  }
+
+  log('====================================================', colors.cyan)
+  log('⚡ GitQuickPush Auto-Push & Big File Engine ⚡', colors.bold + colors.green)
+  log('====================================================', colors.cyan)
+
+  // 1. Ensure Git repo exists
+  const isRepo = runGit(['rev-parse', '--is-inside-work-tree'], { cwd })
+  if (isRepo.status !== 0) {
+    log('📦 Initializing Git repository in current directory...', colors.cyan)
+    runGit(['init'], { cwd })
+  }
+
+  // 2. Configure Git LFS and AI/ML tracking
+  configureGitLfs(cwd)
+
+  // 3. Scan for sensitive files to prevent leaks
+  scanSecrets(cwd)
+
+  // 4. Detect and split big files exceeding GitHub's 100MB limit
+  const bigFiles = findBigFiles(cwd, cwd)
+  if (bigFiles.length > 0) {
+    log(
+      `\nDetected ${bigFiles.length} file(s) exceeding 95MB. Initiating fast split...`,
+      colors.yellow
+    )
+    for (const bFile of bigFiles) {
+      await splitLargeFile(bFile, cwd)
+    }
+  }
+
+  // 5. High-speed Git network optimizations
+  runGit(['config', 'http.postBuffer', '1048576000'], { cwd })
+  runGit(['config', 'core.safecrlf', 'false'], { cwd })
+  runGit(['config', 'pack.windowMemory', '256m'], { cwd })
+  runGit(['config', 'pack.packSizeLimit', '500m'], { cwd })
+
+  // 6. Stage all project files (git add -A)
+  log('\n[1/3] 📂 Staging all project files (git add -A)...', colors.cyan)
+  const addResult = runGit(['add', '-A'], { cwd })
+  if (addResult.status !== 0) {
+    log(`Git add warning: ${addResult.stderr}`, colors.yellow)
+  }
+
+  // 7. Check status & commit
+  const statusCheck = runGit(['status', '--porcelain'], { cwd })
+  const hasChanges = statusCheck.stdout.trim().length > 0
+
+  const timestamp = new Date().toISOString()
+  const customMsg = args.find((a) => !a.startsWith('-')) || `Auto-save: ${timestamp}`
+
+  if (hasChanges) {
+    log(`[2/3] 💾 Committing: "${customMsg}"...`, colors.cyan)
+    runGit(['commit', '-m', customMsg], { cwd })
+  } else {
+    log('[2/3] ℹ️  Working tree clean, no new changes to commit.', colors.gray)
+  }
+
+  // 8. Determine remote and branch
+  const remotesResult = runGit(['remote'], { cwd })
+  const remotes = remotesResult.stdout
+    .trim()
+    .split('\n')
+    .filter((r) => r.trim())
+
+  if (remotes.length === 0) {
+    log('\n⚠️  No remote configured yet. Changes are committed locally!', colors.yellow)
+    log('To link to GitHub, run: git remote add origin <your-github-repo-url>', colors.gray)
+    log('Then run auto-push again!', colors.green)
+    return
+  }
+
+  const branchResult = runGit(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd })
+  let branch = branchResult.stdout.trim() || 'main'
+  if (branch === 'HEAD') branch = 'main'
+
+  log(`[3/3] 🚀 Pushing to remote (${remotes[0]}/${branch}) with live progress...`, colors.cyan)
+
+  let pushCode = await runGitLive(['push', '--progress', remotes[0], `HEAD:${branch}`], { cwd })
+
+  // If rejected because remote has commits, rebase and retry
+  if (pushCode !== 0) {
+    log('\n🔄 Remote has newer changes. Running fast rebase pull...', colors.yellow)
+    const pullCode = await runGitLive(['pull', '--rebase', remotes[0], branch], { cwd })
+    if (pullCode === 0) {
+      log('🚀 Retrying push with live progress...', colors.cyan)
+      pushCode = await runGitLive(['push', '--progress', remotes[0], `HEAD:${branch}`], { cwd })
+    }
+  }
+
+  if (pushCode === 0) {
+    log('\n====================================================', colors.green)
+    log('✨ Auto-Push Completed Successfully! 🚀', colors.bold + colors.green)
+    log('====================================================\n', colors.green)
+  } else {
+    log('\n❌ Push did not complete cleanly. Check network or remote permissions.', colors.red)
+  }
+}
+
+main().catch((err) => {
+  console.error('\nFatal error in auto-push:', err)
+  process.exit(1)
+})

package/bin/cli.js

@@ -101,13 +101,12 @@ Return ONLY valid JSON (no markdown): {"explanation":"...", "commandsToRun":["gi
 
 const program = new Command()
 
-// The Electron executable is provided by the 'electron' package
-let electronPath = ''
-try {
-  electronPath = require('electron')
-} catch (e) {
-  console.error('GitElectron is missing its electron dependency. Run npm install.')
-  process.exit(1)
+function getElectronPath() {
+  try {
+    return require('electron')
+  } catch (e) {
+    return null
+  }
 }
 
 // Path to the application root (where package.json and out/ exist)
@@ -122,6 +121,14 @@ program
   .command('open')
   .description('Open GitElectron desktop application')
   .action(() => {
+    const electronPath = getElectronPath()
+    if (!electronPath) {
+      console.error(
+        'GitElectron desktop dependency (electron) is not installed. Run npm install or use npx.'
+      )
+      process.exit(1)
+    }
+
     console.log('Opening GitElectron...')
 
     // Spawn the electron process and pass the current working directory
@@ -210,4 +217,31 @@ program
     }
   })
 
+program
+  .command('auto-push')
+  .description('Auto-stage, commit, split big files (>95MB), and push with live progress')
+  .argument('[message]', 'Optional custom commit message')
+  .action((message) => {
+    const autoPushPath = path.resolve(__dirname, 'auto-push.js')
+    if (fs.existsSync(autoPushPath)) {
+      if (message) {
+        process.argv = [process.argv[0], autoPushPath, message]
+      } else {
+        process.argv = [process.argv[0], autoPushPath]
+      }
+      require(autoPushPath)
+    }
+  })
+
+program
+  .command('auto-restore')
+  .description('Reassemble all split big file parts into original files with SHA-256 verification')
+  .action(() => {
+    const autoPushPath = path.resolve(__dirname, 'auto-push.js')
+    if (fs.existsSync(autoPushPath)) {
+      process.argv = [process.argv[0], autoPushPath, 'restore']
+      require(autoPushPath)
+    }
+  })
+
 program.parse()

package/out/main/index.js

@@ -408,7 +408,10 @@ async function getCollaborators(sessionId, remoteUrl) {
       return await fetch(url, { headers });
     } catch (e) {
       console.error(`Fetch failed for ${url}:`, e.message);
-      return { ok: false, json: async () => ({ message: e.message || "Network error" }) };
+      return {
+        ok: false,
+        json: async () => ({ message: e.message || "Network error" })
+      };
     }
   };
   const [collabRes, invRes, contribRes] = await Promise.all([
@@ -2063,7 +2066,8 @@ async function masterPush(sessionId, remote, branch) {
       return;
     }
     for (const entry of entries) {
-      if (entry.name === ".git" || entry.name === "node_modules" || entry.name.endsWith(".__lfs_ptr_bak__")) continue;
+      if (entry.name === ".git" || entry.name === "node_modules" || entry.name.endsWith(".__lfs_ptr_bak__"))
+        continue;
       const fullPath = path__namespace.join(dir, entry.name);
       if (entry.isDirectory()) {
         await processRepo(fullPath);