safelaunch 1.0.3 → 1.0.5

package/README.md

@@ -5,46 +5,26 @@
 safelaunch validates your local environment against a required environment contract before you push to production. No more missing variables. No more runtime mismatches. No more production surprises.
 
 ## Install
-```bash
+
 npm install -g safelaunch
-```
 
 ## Quick Start
 
-**Step 1: Create your environment manifest**
-
-Add an `env.manifest.json` file to your project root:
-```json
-{
-  "version": "1",
-  "runtime": {
-    "node": "20"
-  },
-  "variables": {
-    "DATABASE_URL": {
-      "required": true,
-      "description": "PostgreSQL connection string"
-    },
-    "REDIS_URL": {
-      "required": true,
-      "description": "Redis connection string"
-    },
-    "API_KEY": {
-      "required": true,
-      "description": "External API key"
-    }
-  }
-}
-```
-
-**Step 2: Run the validator**
-```bash
+**Step 1: Generate your environment manifest automatically**
+
+Run this in your project folder:
+
+safelaunch init
+
+safelaunch scans your entire codebase, finds every environment variable your app uses, and generates env.manifest.json automatically.
+
+**Step 2: Validate before you push**
+
 safelaunch validate
-```
 
-**Step 3: See exactly what is wrong**
-```
-Running safelaunch...
+**Step 3: See exactly what will break**
+
+Running safelaunch validate gives you:
 
 ❌ MISSING VARIABLES (2 found)
 
@@ -57,23 +37,21 @@ Running safelaunch...
 
 Your environment is not ready for production.
 Fix the issues above and run safelaunch again.
-```
+
+## Commands
+
+safelaunch init      scan project and generate env.manifest.json automatically
+safelaunch validate  validate your .env against the manifest
 
 ## CI Integration
 
 Add this to your GitHub Actions workflow to block deployments automatically:
-```yaml
+
 - name: Install safelaunch
   run: npm install -g safelaunch
 
 - name: Validate environment
   run: safelaunch validate
-```
-
-## What it checks
-
-- Missing required environment variables
-- Runtime version mismatches between local and manifest
 
 ## Built by Orches
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safelaunch",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Backend Reliability Infrastructure - catch what breaks production before it breaks",
   "main": "index.js",
   "bin": {

package/src/validate.js

@@ -4,7 +4,7 @@ const path = require('path');
 function readManifest() {
   const manifestPath = path.join(process.cwd(), 'env.manifest.json');
   if (!fs.existsSync(manifestPath)) {
-    console.log('❌ env.manifest.json not found');
+    console.log('\nNo env.manifest.json found. Run safelaunch init first.\n');
     process.exit(1);
   }
   return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
@@ -13,83 +13,162 @@ function readManifest() {
 function readEnv() {
   const envPath = path.join(process.cwd(), '.env');
   if (!fs.existsSync(envPath)) {
-    return {};
+    console.log('\nNo .env file found.\n');
+    process.exit(1);
   }
+  const envVars = {};
+  const duplicates = [];
+  const seen = new Set();
   const lines = fs.readFileSync(envPath, 'utf8').split('\n');
-  const env = {};
-  lines.forEach((line) => {
-    const [key, value] = line.split('=');
-    if (key && key.trim()) {
-      env[key.trim()] = value ? value.trim() : '';
+  for (const line of lines) {
+    const match = line.match(/^([^=]+)=(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      if (seen.has(key)) duplicates.push(key);
+      seen.add(key);
+      envVars[key] = match[2].trim();
     }
-  });
-  return env;
+  }
+  return { envVars, duplicates };
 }
 
-function checkRuntime(manifest) {
-  if (!manifest.runtime || !manifest.runtime.node) {
-    return null;
+function readEnvExample() {
+  const envExamplePath = path.join(process.cwd(), '.env.example');
+  if (!fs.existsSync(envExamplePath)) return null;
+  const envVars = {};
+  const lines = fs.readFileSync(envExamplePath, 'utf8').split('\n');
+  for (const line of lines) {
+    const match = line.match(/^([^=]+)=(.*)$/);
+    if (match) envVars[match[1].trim()] = match[2].trim();
   }
+  return envVars;
+}
 
-  const requiredVersion = manifest.runtime.node;
-  const actualVersion = process.versions.node.split('.')[0];
+function checkRuntime(manifest) {
+  if (!manifest.runtime || !manifest.runtime.node) return null;
+  const required = String(manifest.runtime.node);
+  const actual = process.version.replace('v', '').split('.')[0];
+  if (required !== actual) return { required, actual };
+  return null;
+}
 
-  if (actualVersion !== requiredVersion) {
-    return {
-      required: requiredVersion,
-      actual: actualVersion,
-    };
+function checkEnvExample(envVars) {
+  const example = readEnvExample();
+  if (!example) return [];
+  const missing = [];
+  for (const key of Object.keys(example)) {
+    if (!envVars[key]) missing.push(key);
   }
+  return missing;
+}
 
-  return null;
+function checkDependencyDrift() {
+  const packagePath = path.join(process.cwd(), 'package.json');
+  const modulesPath = path.join(process.cwd(), 'node_modules');
+  if (!fs.existsSync(packagePath)) return null;
+  if (!fs.existsSync(modulesPath)) return { notInstalled: true, missing: [] };
+  const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  const deps = Object.keys(pkg.dependencies || {});
+  const missing = [];
+  for (const dep of deps) {
+    const depPath = path.join(modulesPath, dep);
+    if (!fs.existsSync(depPath)) missing.push(dep);
+  }
+  return { notInstalled: false, missing };
 }
 
 function validate() {
-  console.log('\nRunning deploycheck...\n');
+  console.log('\nRunning safelaunch...\n');
 
   const manifest = readManifest();
-  const env = readEnv();
-  const variables = manifest.variables;
+  const { envVars, duplicates } = readEnv();
 
   const missing = [];
+  const empty = [];
   const passing = [];
-  const runtimeMismatch = checkRuntime(manifest);
 
-  Object.keys(variables).forEach((key) => {
-    if (variables[key].required && !env[key]) {
+  for (const [key, val] of Object.entries(manifest.variables || {})) {
+    if (val.required && key in envVars && envVars[key] === '') {
+      empty.push(key);
+    } else if (val.required && !(key in envVars)) {
       missing.push(key);
     } else {
       passing.push(key);
     }
-  });
+  }
+
+  const runtimeMismatch = checkRuntime(manifest);
+  const exampleMissing = checkEnvExample(envVars);
+  const drift = checkDependencyDrift();
 
   if (runtimeMismatch) {
-    console.log('❌ RUNTIME MISMATCH\n');
-    console.log(`   Node.js required: v${runtimeMismatch.required}`);
-    console.log(`   Node.js found:    v${runtimeMismatch.actual}\n`);
+    console.log('⚠️  RUNTIME MISMATCH\n');
+    console.log('   Node required: ' + runtimeMismatch.required);
+    console.log('   Node actual:   ' + runtimeMismatch.actual);
+    console.log('');
+  }
+
+  if (duplicates.length > 0) {
+    console.log('⚠️  DUPLICATE VARIABLES (' + duplicates.length + ' found)\n');
+    for (const key of duplicates) {
+      console.log('   ' + key + '   defined more than once in .env');
+    }
+    console.log('');
+  }
+
+  if (drift) {
+    if (drift.notInstalled) {
+      console.log('⚠️  DEPENDENCIES NOT INSTALLED\n');
+      console.log('   node_modules not found. Run npm install.\n');
+    } else if (drift.missing.length > 0) {
+      console.log('⚠️  DEPENDENCY DRIFT (' + drift.missing.length + ' found)\n');
+      for (const dep of drift.missing) {
+        console.log('   ' + dep + '   in package.json but not installed');
+      }
+      console.log('');
+    }
+  }
+
+  if (exampleMissing.length > 0) {
+    console.log('⚠️  MISSING FROM .env.example (' + exampleMissing.length + ' found)\n');
+    for (const key of exampleMissing) {
+      console.log('   ' + key + '   in .env.example but missing from .env');
+    }
+    console.log('');
+  }
+
+  if (empty.length > 0) {
+    console.log('❌ EMPTY VARIABLES (' + empty.length + ' found)\n');
+    for (const key of empty) {
+      console.log('   ' + key + '   required but empty in .env');
+    }
+    console.log('');
   }
 
   if (missing.length > 0) {
-    console.log(`❌ MISSING VARIABLES (${missing.length} found)\n`);
-    missing.forEach((key) => {
-      console.log(`   ${key}   required but missing from .env`);
-    });
+    console.log('❌ MISSING VARIABLES (' + missing.length + ' found)\n');
+    for (const key of missing) {
+      console.log('   ' + key + '   required but missing from .env');
+    }
+    console.log('');
   }
 
   if (passing.length > 0) {
-    console.log(`\n✅ PASSING (${passing.length})\n`);
-    passing.forEach((key) => {
-      console.log(`   ${key}   present`);
-    });
+    console.log('✅ PASSING (' + passing.length + ')\n');
+    for (const key of passing) {
+      console.log('   ' + key + '   present');
+    }
+    console.log('');
   }
 
-  if (runtimeMismatch || missing.length > 0) {
-    console.log('\nYour environment is not ready for production.');
-    console.log('Fix the issues above and run deploycheck again.\n');
+  const hasFailed = runtimeMismatch || missing.length > 0 || empty.length > 0 || duplicates.length > 0 || exampleMissing.length > 0 || (drift && (drift.notInstalled || drift.missing.length > 0));
+
+  if (hasFailed) {
+    console.log('Your environment is not ready for production.\n');
     process.exit(1);
   } else {
-    console.log('\nAll clear. Your environment is ready for production.\n');
+    console.log('Your environment is ready for production.\n');
   }
 }
 
-validate();
+validate();