@siranjeevan/releaseflow 1.0.0

package/firebase.js

@@ -0,0 +1,46 @@
+const admin = require('firebase-admin');
+const fs = require('fs');
+const path = require('path');
+
+let db, storage;
+
+const CONFIG_PATH = path.join(__dirname, 'config.json');
+
+function isConfigured() {
+  if (!fs.existsSync(CONFIG_PATH)) return false;
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    return !!(config.serviceAccountPath && fs.existsSync(config.serviceAccountPath));
+  } catch (e) {
+    return false;
+  }
+}
+
+function initFirebase() {
+  if (!isConfigured()) {
+    throw new Error('Firebase is not configured. Run "myapp configure" first.');
+  }
+
+  const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  const serviceAccount = require(path.resolve(config.serviceAccountPath));
+
+  if (!admin.apps.length) {
+    admin.initializeApp({
+      credential: admin.credential.cert(serviceAccount),
+      storageBucket: config.storageBucket
+    });
+  }
+
+  db = admin.firestore();
+  storage = admin.storage().bucket();
+
+  return { db, storage, admin };
+}
+
+async function getLiveVersion() {
+  const { db } = initFirebase();
+  const doc = await db.collection('app_config').doc('version').get();
+  return doc.exists ? doc.data().latest_version : '0.0.0';
+}
+
+module.exports = { initFirebase, isConfigured, CONFIG_PATH, getLiveVersion };

package/index.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+const inquirer = require('inquirer');
+const path = require('path');
+const fs = require('fs');
+const yaml = require('js-yaml');
+const semver = require('semver');
+const { spawn } = require('child_process');
+const { 
+  uploadApk, 
+  updateFirestore, 
+  listAvailableVersions, 
+  rollbackToVersion 
+} = require('./uploader');
+const { isConfigured, CONFIG_PATH, getLiveVersion } = require('./firebase');
+
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+
+async function main() {
+  yargs(hideBin(process.argv))
+    .command('release', 'Build, Detect and Upload in ONE command!', {}, async () => {
+      console.log('\x1b[36m%s\x1b[0m', '\n🚀 --- ReleaseFlow All-in-One Generator --- 🚀');
+      if (!isConfigured()) {
+        console.log('\x1b[33mFirebase is not configured yet.\x1b[0m');
+        await runConfigureFlow();
+      }
+      await runFullReleaseFlow();
+    })
+    .command('rollback', 'Rollback to a previous APK version', {}, async () => {
+      console.log('\x1b[36m%s\x1b[0m', '\n⏪ --- Rollback to Previous Version --- ⏪');
+      if (!isConfigured()) {
+        await runConfigureFlow();
+      }
+      await runRollbackFlow();
+    })
+    .command('configure', 'Set up Firebase credentials', {}, async () => {
+      console.log('\x1b[36m%s\x1b[0m', '\n--- Configure Firebase Credentials ---');
+      await runConfigureFlow();
+    })
+    .demandCommand(1, 'Please specify a command (e.g., release, rollback, configure)')
+    .help()
+    .argv;
+}
+
+const PUBSPEC_PATH = path.resolve(__dirname, '../flutter_app/pubspec.yaml');
+
+function getPubspecVersion() {
+  try {
+    if (fs.existsSync(PUBSPEC_PATH)) {
+      const doc = yaml.load(fs.readFileSync(PUBSPEC_PATH, 'utf8'));
+      return doc.version.split('+')[0];
+    }
+  } catch (e) {
+    console.error('Warning: Could not read version from pubspec.yaml');
+  }
+  return null;
+}
+
+function updatePubspecVersion(newVersion) {
+  try {
+    const rawPubspec = fs.readFileSync(PUBSPEC_PATH, 'utf8');
+    const updatedPubspec = rawPubspec.replace(/^version: ([\d\.]+)(.*)$/m, (match, v, build) => {
+      return `version: ${newVersion}${build || '+1'}`;
+    });
+    fs.writeFileSync(PUBSPEC_PATH, updatedPubspec);
+    return true;
+  } catch (e) {
+    console.error('Error updating pubspec.yaml: ' + e.message);
+    return false;
+  }
+}
+
+async function runConfigureFlow() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'serviceAccountPath',
+      message: 'Enter the path to your Firebase Service Account JSON file:',
+      validate: (input) => {
+        const fullPath = path.resolve(process.cwd(), input);
+        if (fs.existsSync(fullPath) && (input.endsWith('.json') || fs.statSync(fullPath).isFile())) {
+          return true;
+        }
+        return 'Please provide a valid path to your service account .json file.';
+      }
+    },
+    {
+      type: 'input',
+      name: 'storageBucket',
+      message: 'Enter your Firebase Storage Bucket name:',
+      default: 'testing-dhwayam.firebasestorage.app'
+    }
+  ]);
+
+  const config = { 
+    serviceAccountPath: path.resolve(process.cwd(), answers.serviceAccountPath),
+    storageBucket: answers.storageBucket
+  };
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  console.log('\x1b[32m✔ Configuration saved successfully!\x1b[0m\n');
+}
+
+async function runFullReleaseFlow() {
+  console.log('\x1b[34mChecking versions and history...\x1b[0m');
+  
+  const liveVersion = await getLiveVersion();
+  const allVersions = await listAvailableVersions();
+  const maxVersion = allVersions.length > 0 ? allVersions[0] : '0.0.0';
+  let localVersion = getPubspecVersion();
+
+  console.log(`- Current Live Version: \x1b[33m${liveVersion}\x1b[0m`);
+  console.log(`- Highest Released Version: \x1b[33m${maxVersion}\x1b[0m`);
+  console.log(`- Version in pubspec.yaml: \x1b[33m${localVersion}\x1b[0m`);
+
+  // Logic: If local version is already in storage, suggest a bump
+  if (semver.lte(localVersion, maxVersion)) {
+    console.log('\n\x1b[33mWarning: This version (or higher) has already been released once!\x1b[0m');
+    const suggestedVersion = semver.inc(maxVersion, 'patch');
+    
+    const choice = await inquirer.prompt([{
+      type: 'list',
+      name: 'action',
+      message: `What would you like to do?`,
+      choices: [
+        { name: `Automatically upgrade code to ${suggestedVersion} and release`, value: 'auto' },
+        { name: 'Cancel release', value: 'cancel' }
+      ]
+    }]);
+
+    if (choice.action === 'cancel') return;
+    
+    if (choice.action === 'auto') {
+      localVersion = suggestedVersion;
+      updatePubspecVersion(localVersion);
+      console.log(`\x1b[32m✔ Updated pubspec.yaml to ${localVersion}\x1b[0m`);
+    }
+  } else {
+    console.log('\x1b[32m✔ New version detected! Proceeding...\x1b[0m\n');
+  }
+
+  // Automated Build
+  console.log('\n\x1b[35m🛠️  Building Optimized APK (arm64)... Please wait...\x1b[0m');
+  
+  const build = spawn('flutter', ['build', 'apk', '--release', '--split-per-abi', '--target-platform', 'android-arm64'], {
+    cwd: path.resolve(__dirname, '../flutter_app'),
+    stdio: 'inherit'
+  });
+
+  build.on('close', async (code) => {
+    if (code !== 0) {
+      console.error('\x1b[31m❌ Build failed!\x1b[0m');
+      return;
+    }
+
+    console.log('\x1b[32m✔ Build Successful!\x1b[0m');
+    const apkPath = '../flutter_app/build/app/outputs/flutter-apk/app-arm64-v8a-release.apk';
+    const fullApkPath = path.resolve(__dirname, apkPath);
+
+    const answers = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'forceUpdate',
+      message: 'Force update for this release?',
+      default: false
+    }]);
+
+    try {
+      console.log('\n\x1b[33m🚀 Starting Cloud Release Flow...\x1b[0m');
+      const downloadUrl = await uploadApk(fullApkPath, localVersion);
+      await updateFirestore(localVersion, downloadUrl, answers.forceUpdate);
+
+      console.log('\n\x1b[35mSummary:\x1b[0m');
+      console.log(`Version: ${localVersion}`);
+      console.log(`Force Update: ${answers.forceUpdate ? 'Yes' : 'No'}`);
+      console.log('\n\x1b[32m🎉 Release Complete! Your app is now LIVE. 🎉\x1b[0m');
+    } catch (error) {
+      console.error('\x1b[31m\n❌ Error: ' + error.message + '\x1b[0m');
+    }
+  });
+}
+
+async function runRollbackFlow() {
+  console.log('\x1b[34mFetching available versions from Storage...\x1b[0m');
+  const versions = await listAvailableVersions();
+
+  if (versions.length === 0) {
+    console.log('\x1b[31m❌ No previous versions found.\x1b[0m');
+    return;
+  }
+
+  const currentLive = await getLiveVersion();
+  console.log(`Current Live Version: \x1b[33m${currentLive}\x1b[0m`);
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'version',
+      message: 'Select a version to rollback to:',
+      choices: versions.map(v => ({
+        name: v === currentLive ? `${v} (Already Live)` : v,
+        value: v
+      }))
+    },
+    {
+      type: 'confirm',
+      name: 'forceUpdate',
+      message: 'Force update for this rollback?',
+      default: true
+    }
+  ]);
+
+  try {
+    console.log(`\n\x1b[33m⏪ Rolling back to version ${answers.version}...\x1b[0m`);
+    await rollbackToVersion(answers.version, answers.forceUpdate);
+    console.log('\n\x1b[32m✔ Success! The database has been rolled back.\x1b[0m');
+  } catch (error) {
+    console.error('\n\x1b[31m❌ Rollback failed: ' + error.message + '\x1b[0m');
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@siranjeevan/releaseflow",
+  "version": "1.0.0",
+  "description": "Automated Flutter Release Manager",
+  "main": "index.js",
+  "bin": {
+    "releaseflow": "index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "flutter",
+    "release",
+    "firebase",
+    "automation"
+  ],
+  "author": "Jeevith",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.7.9",
+    "cli-progress": "^3.12.0",
+    "firebase-admin": "^13.0.1",
+    "inquirer": "^8.0.0",
+    "js-yaml": "^4.1.0",
+    "semver": "^7.7.1",
+    "yargs": "^17.7.2"
+  }
+}

package/uploader.js

@@ -0,0 +1,126 @@
+const { initFirebase } = require('./firebase.js');
+const fs = require('fs');
+const path = require('path');
+const semver = require('semver');
+
+async function cleanupOldReleases(storage) {
+  try {
+    const [files] = await storage.getFiles({ prefix: 'releases/' });
+    
+    const releaseFiles = files
+      .map(file => {
+        // Improved regex to catch 1.0.4, 1.0.4+1, etc.
+        const match = file.name.match(/app-v([\d\.\+\w]+)\.apk/);
+        return match ? { file, version: match[1] } : null;
+      })
+      .filter(item => item !== null);
+
+    releaseFiles.sort((a, b) => {
+      try {
+        // Clean version for semver comparison (1.0.4+1 -> 1.0.4)
+        const vA = a.version.split('+')[0];
+        const vB = b.version.split('+')[0];
+        return semver.rcompare(vA, vB);
+      } catch (e) {
+        return 0;
+      }
+    });
+
+    if (releaseFiles.length > 3) {
+      console.log(`\n\x1b[34mCleaning up storage: keeping 3 latest history APKs, deleting oldest...\x1b[0m`);
+      const filesToDelete = releaseFiles.slice(3);
+      for (const item of filesToDelete) {
+        console.log(`- Removing obsolete APK: ${item.file.name}`);
+        await item.file.delete();
+      }
+    }
+  } catch (error) {
+    console.warn('\x1b[33mWarning: Storage cleanup failed: ' + error.message + '\x1b[0m');
+  }
+}
+
+async function uploadApk(apkPath, version) {
+  const { storage } = initFirebase();
+  const fileName = `releases/app-v${version}.apk`;
+  const destination = fileName;
+
+  console.info(`\x1b[34mUploading APK to: ${destination}...\x1b[0m`);
+
+  await storage.upload(apkPath, {
+    destination,
+    metadata: {
+      contentType: 'application/vnd.android.package-archive',
+    },
+  });
+
+  await cleanupOldReleases(storage);
+
+  const file = storage.file(destination);
+  const [url] = await file.getSignedUrl({
+    action: 'read',
+    expires: '03-01-2099',
+  });
+
+  return url;
+}
+
+async function updateFirestore(version, url, forceUpdate) {
+  const { db } = initFirebase();
+  const configRef = db.collection('app_config').doc('version');
+
+  console.info(`\x1b[34mUpdating Firestore status to: ${version}...\x1b[0m`);
+
+  await configRef.set({
+    latest_version: version,
+    apk_url: url,
+    force_update: forceUpdate,
+    updated_at: new Date().toISOString()
+  });
+
+  return true;
+}
+
+async function listAvailableVersions() {
+  const { storage } = initFirebase();
+  const [files] = await storage.getFiles({ prefix: 'releases/' });
+  
+  return files
+    .map(file => {
+      const match = file.name.match(/app-v([\d\.\+\w]+)\.apk/);
+      return match ? match[1] : null;
+    })
+    .filter(v => v !== null)
+    .sort((a, b) => {
+       try {
+         return semver.rcompare(a.split('+')[0], b.split('+')[0]);
+       } catch (e) { return 0; }
+    });
+}
+
+async function rollbackToVersion(version, forceUpdate) {
+  const { storage, db } = initFirebase();
+  const fileName = `releases/app-v${version}.apk`;
+  const file = storage.file(fileName);
+
+  const [exists] = await file.exists();
+  if (!exists) {
+    throw new Error(`Version ${version} does not exist in Storage.`);
+  }
+
+  const [url] = await file.getSignedUrl({
+    action: 'read',
+    expires: '03-01-2099',
+  });
+
+  const configRef = db.collection('app_config').doc('version');
+  await configRef.set({
+    latest_version: version,
+    apk_url: url,
+    force_update: forceUpdate,
+    updated_at: new Date().toISOString()
+  });
+
+  return url;
+}
+
+module.exports = { uploadApk, updateFirestore, listAvailableVersions, rollbackToVersion };