gina 0.1.1-alpha.99 → 0.1.2-alpha.1

package/framework/{v0.1.1-alpha.99 → v0.1.2-alpha.1}/lib/cmd/project/add.js

@@ -1,4 +1,7 @@
 var fs          = require('fs');
+var os          = require('os');
+var util        = require('util');
+var promisify   = util.promisify;
 
 var CmdHelper   = require('./../helper');
 var Shell       = lib.Shell;
@@ -28,14 +31,20 @@ function Add(opt, cmd) {
 
         // check CMD configuration
         if ( !isCmdConfigured() ) return false;
-        
-        local.imported = false;
+        for (let i=3, len=process.argv.length; i<len; i++) {
+            if ( /^\-\-start\-port\-from\=/.test(process.argv[i]) ) {
+                self.startFrom = process.argv[i].split(/\=/)[1]
+            }
+        }
+
+        local.imported = ( /\:import/i.test(self.task) ) ? true : false;
         if ( checkImportMode() ) {
             return;
         }
 
         var err         = false
             , folder    = null
+            , file      = null
         ;
 
         folder = new _(self.projectLocation);
@@ -50,45 +59,44 @@ function Add(opt, cmd) {
             }
         }
 
-        
-        // creating project file
-        var file = new _(self.projectLocation + '/manifest.json', true);
+        // creating package file
+        file = new _(self.projectLocation + '/package.json', true);
         if ( !file.existsSync() ) {
-            createProjectFile( file.toString() )
+            createPackageFile( file.toString() )
         } else {
-            console.warn('[ manifest.json ] already exists in this location: '+ file);
+            console.warn('[ package.json ] already exists in this location: '+ file + '\nUpdating package.json...');
+            createPackageFile( file.toString(), true )
         }
 
+        // creating project manifest
+        file = new _(self.projectManifestPath, true);
+        // override for `add` & `import`
+        // if ( !file.existsSync() ) {
+            createManifestFile( file.toString() )
+        // } else {
+        //     console.warn('[ manifest.json ] already exists in this location: '+ file);
+        // }
+
         // creating env file
-        var file = new _(self.projectLocation + '/env.json', true);
+        file = new _(self.projectLocation + '/env.json', true);
         if ( !file.existsSync() ) {
             createEnvFile( file.toString() )
         } else {
             console.warn('[ env.json ] already exists in this location: '+ file);
         }
-
-        // creating package file
-        file = new _(self.projectLocation + '/package.json', true);
-        if ( !file.existsSync() ) {
-            createPackageFile( file.toString() )
-        } else {
-            console.warn('[ package.json ] already exists in this location: '+ file);
-
-            end()
-        }
     }
 
     var checkImportMode = function() {
-        
+
         if ( self.task != 'project:import')
             return;
-        
+
         console.debug('Starting import mode @'+ self.projectName );
         if (!self.projects[self.projectName ]) {
             console.error('[ '+ self.projectName  +' ] is not an existing project. Instead, use gina projet:add @'+ self.projectName +' --path=/your/project_location');
             process.exit(1)
         }
-        
+
         if ( typeof(self.projects[self.projectName ]) != 'undefined' ) {
             // import if exists but path just changed
             if ( typeof(self.projects[self.projectName ].path) != 'undefined') {
@@ -99,13 +107,13 @@ function Add(opt, cmd) {
                     self.projects[self.projectName ].path = self.projectLocation;
 
                     var target = _(GINA_HOMEDIR + '/projects.json')
-                        , projects = self.projects;
+                        , projects = JSON.clone(self.projects);
 
                     lib.generator.createFileFromDataSync(
                         projects,
                         target
                     );
-                   
+
 
                     var ginaModule = _( self.projectLocation +'/node_modules/gina',true );
 
@@ -116,7 +124,7 @@ function Add(opt, cmd) {
                                 process.exit(1)
                             },
                             function onSuccess() {
-                                local.imported = true;                               
+                                local.imported = true;
                                 end();
                                 return true;
                             })
@@ -134,15 +142,49 @@ function Add(opt, cmd) {
         }
     }
 
-    var createProjectFile = function(target) {
+    var createManifestFile = function(target) {
 
         loadAssets();
 
         var conf        = _(getPath('gina').core +'/template/conf/manifest.json', true);
-        var contentFile = require(conf);
+        var contentFile = requireJSON(conf);
+        var packageContent = requireJSON(_(self.projectLocation + '/package.json', true));
+        var version = packageContent.version || "1.0.0";
+        // hostname by default
+        var rootDomain = os.hostname();
+        // fqdn by default
+        var shortVersion = GINA_SHORT_VERSION;// jshint ignore:line
+        home = GINA_HOMEDIR;// jshint ignore:line
+        var homeVersionDirObj = new _( home +'/'+ shortVersion, true );
+        var settingsPath = _( homeVersionDirObj.toString() +'/settings.json', true );// jshint ignore:line
+        if ( new _(settingsPath).existsSync() ) {
+            var settings = requireJSON(settingsPath);// jshint ignore:line
+            if ( settings.hostname != 'localhost' ) {
+                rootDomain = settings.hostname;
+            }
+        }
+        var bundles = {};
+        if ( new _(target).existsSync() ) {
+            var existingManifest = requireJSON(target);
+            if ( typeof(existingManifest.rootDomain) != 'undefined' && existingManifest.rootDomain != os.hostname() ) {
+                rootDomain = existingManifest.rootDomain;
+            }
+            existingManifest.version = version;
+            existingManifest.rootDomain = rootDomain;
+            if ( typeof(existingManifest.bundles) != 'undefined' ) {
+                bundles = JSON.clone(existingManifest.bundles);
+                delete existingManifest.bundles;
+            }
+
+            contentFile = merge(existingManifest, contentFile);
+            contentFile.bundles = bundles;
+        }
+
         var dic = {
             "project"   : self.projectName,
-            "version"   : "1.0.0"
+            "version"   : version,
+            "scope"     : self.defaultScope,
+            "rootDomain": rootDomain
         };
 
         contentFile = whisper(dic, contentFile); //data
@@ -153,7 +195,7 @@ function Add(opt, cmd) {
     }
 
     var createEnvFile = function(target) {
-        
+
         lib.generator.createFileFromDataSync(
             {},
             target
@@ -161,12 +203,14 @@ function Add(opt, cmd) {
     }
 
 
-    var createPackageFile = function(target) {
+    var createPackageFile = function(target, isCreatedFromExistingPackage) {
 
         loadAssets();
 
         var conf = _(getPath('gina').core +'/template/conf/package.json', true);
-        var contentFile = require(conf);
+        var contentFile = requireJSON(conf);
+
+
         var dic = {
             'project' : self.projectName,
             'node_version' : GINA_NODE_VERSION.match(/\d+/g).join('.'),
@@ -174,6 +218,18 @@ function Add(opt, cmd) {
         };
 
         contentFile = whisper(dic, contentFile);//data
+
+        // Updating package.json if needed
+        if (
+            typeof(isCreatedFromExistingPackage) != 'undefined'
+            && /^true$/i.test(isCreatedFromExistingPackage)
+        ) {
+            var existingPack = require(target);
+            contentFile = merge(contentFile, existingPack);
+            contentFile.version = existingPack.version || "1.0.0";
+            new _(target, true).rmSync()
+        }
+
         lib.generator.createFileFromDataSync(
             contentFile,
             target
@@ -182,31 +238,56 @@ function Add(opt, cmd) {
         end(true)
     }
 
-    var end = function(created) {
-
+    var end = async function(created) {
 
         var target = _(GINA_HOMEDIR + '/projects.json')
-            , projects = self.projects
-            , error = false;
+            , projects = JSON.clone(self.projects)
+            , error = false
+        ;
 
-        
         projects[self.projectName] = {
-            "path": self.projectLocation,
-            "framework": "v" + GINA_VERSION,
-            "envs": self.envs,
-            "def_env": self.defaultEnv,
-            "dev_env": self.devEnv,
-            "protocols": (created) ? self.protocolsAvailable : self.protocols,
-            "def_protocol": self.defaultProtocol,
-            "schemes": (created) ? self.schemesAvailable : self.schemes,
-            "def_scheme": self.defaultScheme
+            "path"              : self.projectLocation,
+            "homedir"           : self.projectHomedir,
+            "def_prefix"        : GINA_PREFIX,
+            "framework"         : "v" + GINA_VERSION,
+            "envs"              : self.envs,
+            "def_env"           : self.defaultEnv,
+            "dev_env"           : self.devEnv,
+            "scopes"            : self.scopes,
+            "def_scope"         : self.defaultScope,
+            "local_scope"       : self.localScope,
+            "production_scope"  : self.productionScope,
+            "protocols"         : (created) ? self.protocolsAvailable : self.protocols,
+            "def_protocol"      : self.defaultProtocol,
+            "schemes"           : (created) ? self.schemesAvailable : self.schemes,
+            "def_scheme"        : self.defaultScheme
         };
-        
-        // create/update ports, protocols & schemes
-        if ( /^true$/.test(local.imported) ) {
-            addBundlePorts(0);
+
+        // On import only
+        if ( /^true$/i.test(local.imported) ) {
+            self.bundles.sort();
+            var bundleErr = null;
+            // Create/update ports, protocols & schemes
+            await promisify(addBundlePorts)(0)
+                .catch( function onBundlePortsError(err) {
+                    bundleErr = err;
+                });
+            if (bundleErr) {
+                console.error('Could not finalize [ addBundlePorts ] \n'+ bundleErr.stack);
+                process.exit(1)
+            }
+
+            // Create/update manifest
+            await promisify(addBundleToManifest)(null, 0)
+                .catch( function onBundleError(err) {
+                    bundleErr = err;
+                });
+            if (bundleErr) {
+                console.error('Could not finalize [ addBundleToManifest ] \n'+ bundleErr.stack);
+                process.exit(1)
+            }
         }
-        
+
 
         // writing file
         lib.generator.createFileFromDataSync(
@@ -214,13 +295,15 @@ function Add(opt, cmd) {
             target
         );
 
+
+
         var onSuccess = function () {
-            if ( self.task == 'project:add' ) {
+            if ( /project\:add/i.test(self.task) ) {
                 console.log('Project [ '+ self.projectName +' ] has been added');
             } else {
                 console.log('Project [ '+ self.projectName +' ] has been imported');
             }
-                        
+
             process.exit(0)
         }
 
@@ -228,15 +311,15 @@ function Add(opt, cmd) {
             console.error('Could not finalize [ '+ self.projectName +' ] install\n'+ err.stack);
             process.exit(1)
         }
-        
-        
+
+
 
 
         var ginaModule = new _( self.projectLocation +'/node_modules/gina',true );
 
         if ( !ginaModule.existsSync() ) {
             linkGina(onError, onSuccess)
-        } else {
+        } else if ( /^true$/i.test(GINA_GLOBAL_MODE) ) {
 
             error = ginaModule.rmSync();
 
@@ -247,13 +330,15 @@ function Add(opt, cmd) {
                 linkGina(onError, onSuccess)
             }
 
+        } else {
+            onSuccess()
         }
     }
-    
+
     var hasPastProtocolAndSchemeCheck = function (protocol, scheme, exitOnError) {
         loadAssets();
-        
-        // are selected protocol & scheme allowed ?        
+
+        // are selected protocol & scheme allowed ?
         if ( self.protocolsAvailable.indexOf(protocol) < 0 ) {
             console.error('Protocol [ '+scheme+' ] is not an allowed protocol: check your framework configuration (~/main.json)');
             if ( typeof(exitOnError) != 'undefined' && exitOnError)
@@ -265,31 +350,32 @@ function Add(opt, cmd) {
                 process.exit(1)
         }
     }
-    
+
     /**
+     * addBundlePorts
      * Add / update project default protocol, scheme & ports
-     * 
+     *
+     * NB.: also used in `port:reset` task
+     *
      * @param {number} b - Bundle index
+     * @callback done
+     *  @param {object|bool} err
+     *  @param {array} ports
      */
-    
-    // var addBundlePorts = function(b) {
-        
-    // }
-    
-    var addBundlePorts = function(b) {
+    var addBundlePorts = async function(b, done) {
         loadAssets();
-        
+
         if (b > self.bundles.length-1) { // writing to files on complete
-            
-            hasPastProtocolAndSchemeCheck(self.defaultProtocol, self.defaultScheme, true);              
-            
+
+            hasPastProtocolAndSchemeCheck(self.defaultProtocol, self.defaultScheme, true);
+
             //console.debug('self.protocols ...', self.protocols);
             // get user protocols list
             var protocols = JSON.clone(self.protocols);
             // get user schemes list
             var schemes = JSON.clone(self.schemes);
             var projectConfig   = JSON.clone(self.projects);
-                        
+
             //console.debug('about to update project ports conf\n\rBundles: '+ JSON.stringify(self.projectData, null, 4));
             var ports               = JSON.clone(self.portsData) // cloning
                 , portsReverse      = JSON.clone(self.portsReverseData) // cloning
@@ -300,165 +386,170 @@ function Add(opt, cmd) {
                 , defaultProtocol   = self.defaultProtocol
                 , defaultScheme     = self.defaultScheme
             ;
-            
+
             if ( typeof(ports[defaultProtocol]) == 'undefined' ) {
                 ports[defaultProtocol] = {};
             }
-            
+
             if ( typeof(ports[defaultProtocol][defaultScheme]) == 'undefined' ) {
                 ports[defaultProtocol][defaultScheme] = {};
             }
-    
+
             // to fixe bundle settings inconsistency
-            var bundleConfig    = null;        
+            var bundleConfig    = null;
             var settingsPath    = null;
             var bundleSettingsUpdate = false;
-    
+
             var portValue = null, portReverseValue = null;
             var re = null, portsListStr = JSON.stringify(self.portsData);
-    
+
             for (;i < portsList.length; ++i) {
-    
+
                 if ( !ports.count() ) {
                     ports[defaultProtocol] = {};
                     ports[defaultProtocol][defaultScheme] = {};
                     ports[defaultProtocol][defaultScheme][ portsList[i] ] = null;
                 }
-    
-                
-                for ( var protocol in ports ) {
+
+
+                for ( let protocol in ports ) {
                     // ignore unmatched protocol : in case of the framework update
                     if ( self.protocolsAvailable.indexOf(protocol) < 0) {
                         delete ports[protocol];
                         if ( protocols.indexOf(protocol) < 0) {
-                            delete self.protocols[self.protocols.indexOf(protocol)]; 
-                        }                                               
-                        continue; 
+                            delete self.protocols[self.protocols.indexOf(protocol)];
+                        }
+                        continue;
                     }
-                        
-                    for (var scheme in ports[protocol]) {
-                        
+
+                    for (let scheme in ports[protocol]) {
+
+                        // skipping none `https` schemes for `http/2`
+                        if ( /^http\/2/.test(protocol) && scheme != 'https' ) {
+                            console.debug('skipping none `https` schemes for `http/2`');
+                            continue;
+                        }
+
                         if ( !ports[protocol][scheme].count() ) {
                             ports[protocol][scheme][ portsList[i] ] = null;
                         }
-                        
-                        for (var b = 0, bLen = self.bundles.length; b < bLen; ++b) {
-                            
-                            local.bundle = self.bundles[b];                            
-                            
+
+                        for (let b = 0, bLen = self.bundles.length; b < bLen; ++b) {
+
+                            local.bundle = self.bundles[b];
+
                             // bundle settings inconsistency check @ fix
-                            bundleName              = local.bundle;                              
-                            bundleConfig            = self.bundlesByProject[self.projectName][bundleName];        
-                            settingsPath            = _(bundleConfig.configPaths.settings, true);   
+                            bundleName              = local.bundle;
+                            bundleConfig            = self.bundlesByProject[self.projectName][bundleName];
+                            settingsPath            = _(bundleConfig.configPaths.settings, true);
                             bundleSettingsUpdate    = false;
-                            
+
                             if ( fs.existsSync(settingsPath) ) {
-                                                                                            
-                                bundleSettings  = requireJSON(settingsPath);  
-                                //console.debug('found [ '+ bundleName +' ] settings ');                             
-                                if ( typeof(bundleSettings.server) != 'undefined' ) {           
-                                    // update only if given bundle protocol setting not in project protocols list  
-                                    // use project def_protocol by default in that case                          
-                                    if ( 
-                                        typeof(bundleSettings.server.protocol) != 'undefined' 
+
+                                bundleSettings  = requireJSON(settingsPath);
+                                //console.debug('found [ '+ bundleName +' ] settings ');
+                                if ( typeof(bundleSettings.server) != 'undefined' ) {
+                                    // update only if given bundle protocol setting not in project protocols list
+                                    // use project def_protocol by default in that case
+                                    if (
+                                        typeof(bundleSettings.server.protocol) != 'undefined'
                                         && protocols.indexOf(bundleSettings.server.protocol) < 0
                                     ) {
                                         bundleSettings.server.protocol = self.defaultProtocol;
                                         bundleSettingsUpdate = true
                                     }
-                                    
-                                    // update only if given bundle scheme setting not in project schemes list  
-                                    // use project def_scheme by default in that case                          
-                                    if ( 
-                                        typeof(bundleSettings.server.scheme) != 'undefined' 
+
+                                    // update only if given bundle scheme setting not in project schemes list
+                                    // use project def_scheme by default in that case
+                                    if (
+                                        typeof(bundleSettings.server.scheme) != 'undefined'
                                         && schemes.indexOf(bundleSettings.server.scheme) < 0
                                     ) {
                                         bundleSettings.server.scheme = self.defaultScheme;
                                         bundleSettingsUpdate = true
                                     }
-                                    
-                                    if (bundleSettingsUpdate) {                                        
+
+                                    if (bundleSettingsUpdate) {
                                         lib.generator.createFileFromDataSync(bundleSettings, settingsPath);
                                         console.debug('updated [ '+ bundleName +' ] settings');
                                     }
-                                }                            
-                            }                           
-                            
+                                }
+                            }
+
                             // updating ports
-                            for (var port in ports[protocol][scheme]) {    
-                                
-                                    
-                                    for (var e = 0, envsLen = envs.length; e < envsLen; ++e ) {
-        
+                            for (let port in ports[protocol][scheme]) {
+
+
+                                    for (let e = 0, envsLen = envs.length; e < envsLen; ++e ) {
+
                                         if (!portsList[i]) break;
-                                        
+
                                         // ports
                                         portValue = local.bundle +'@'+ self.projectName +'/'+ envs[e];
                                         re = new RegExp(portValue);
-                                        
-                                        
-                                        if ( !re.test(portsListStr) ) { 
-                                            
+
+
+                                        if ( !re.test(portsListStr) ) {
+
                                             // ports - add only if not existing
                                             isPortUsed = false;
-                                            
-                                            for (var portNum in ports[protocol][scheme]) {
+
+                                            for (let portNum in ports[protocol][scheme]) {
                                                 if ( ports[protocol][scheme][portNum] == portValue ) {
                                                     isPortUsed = true;
                                                     break;
-                                                }                                                
+                                                }
                                             }
                                             //console.debug('portValue -> ', portValue+ ': '+ portsList[i] +' ? ' +isPortUsed);
                                             if (!isPortUsed) {
                                                 //console.debug(local.bundle, ': ',portsList[i], ' => ', portValue);
                                                 ports[protocol][scheme][ portsList[i] ] = portValue;
-                                                
+
                                                 // reverse ports
                                                 portReverseValue = portsList[i];
                                                 if ( typeof(portsReverse[ local.bundle +'@'+ self.projectName ]) == 'undefined' )
                                                     portsReverse[ local.bundle +'@'+ self.projectName ] = {};
-                
+
                                                 if ( typeof(portsReverse[ local.bundle +'@'+ self.projectName ][ envs[e] ]) == 'undefined' )
                                                     portsReverse[ local.bundle +'@'+ self.projectName ][ envs[e] ] = {};
-                                                    
+
                                                 if ( typeof(portsReverse[ local.bundle +'@'+ self.projectName ][ envs[e] ][ protocol ]) == 'undefined' )
                                                     portsReverse[ local.bundle +'@'+ self.projectName ][ envs[e] ][ protocol ] = {};
-                
+
                                                 // erasing in order to keep consistency
                                                 portsReverse[ local.bundle +'@'+ self.projectName ][ envs[e] ][ protocol ][ scheme ] = ~~portsList[i];
-                                                
-                                            
+
+
+                                                ++i;
                                             }
-            
-                                            ++i;
                                         }
                                     }
-                                        
+
                                 }
                         }
-                    }  
+                    }
                 }
             }
-                        
+
             // save to ~/.gina/projects.json
             lib.generator.createFileFromDataSync(projectConfig, self.projectConfigPath);
-    
+
             // save to ~/.gina/ports.json
             //console.debug('data \n'+ JSON.stringify(self.portsData, null, 4) +'\n\rcurrent \n'+ JSON.stringify(ports, null, 4));
             lib.generator.createFileFromDataSync( merge(self.portsData, ports), self.portsPath);
-    
+
             // save to ~/.gina/ports.reverse.json
             lib.generator.createFileFromDataSync( merge(self.portsReverseData, portsReverse), self.portsReversePath);
 
-            
-            return;
+
+            return done(false);
         }
 
-        //console.debug('Bundles list on project import [ '+ b +' ]', self.bundles.length, self.bundles);       
+        //console.debug('Bundles list on project import [ '+ b +' ]', self.bundles.length, self.bundles);
         var options     = {}
             , bundle    = self.bundles[b]
         ;
-        
+
         if ( /^[a-z0-9_.]/.test(bundle) ) {
 
             local.b             = b;
@@ -466,38 +557,133 @@ function Add(opt, cmd) {
 
             // find available port
             options = {
-                ignore  : merge(self.portsGlobalList, local.ports),
+                // ignore  : merge(self.portsGlobalList, local.ports),
+                ignore  : local.ports,
                 // get for each bundle ports for available protocol, scheme & env
-                len   : ( self.protocolsAvailable.length * self.schemesAvailable.length * self.envs.length * self.bundles.length )
+                limit   : ( self.protocolsAvailable.length * self.schemesAvailable.length * self.envs.length * self.bundles.length )
             };
-            
-            
-            // scanning for available ports ...
-            scan(options, function(err, ports){
 
+            // defining range startFrom depending of the project index (self.projectsList - OK only)...
+            if (self.startFrom) {
+                options.startFrom = self.startFrom;
+            } else { // Find startFrom out of projects
+                options.startFrom = ~~(''+ (self.projectsList.indexOf(self.projectName)+3) + 100);
+            }
+            // scanning for available ports ...
+            // var scanErr = null;
+            // await promisify(scan)(options)
+            //     .catch(function onScanErr(err) {
+            //         scanErr = err;
+            //     })
+            //     .then( function onPortsFound(ports) {
+            //         for (let p = 0; p < ports.length; ++p) {
+            //             local.ports.push(ports[p])
+            //         }
+
+            //         local.ports.sort();
+
+            //         ++local.b;
+            //         addBundlePorts(local.b, done);
+            //     });
+
+            // if (scanErr) {
+            //     console.error(err.stack|err.message);
+            //     process.exit(1)
+            // }
+
+            await scan(options, function(err, ports){
                 if (err) {
                     console.error(err.stack|err.message);
                     process.exit(1)
                 }
 
 
-                for (var p = 0; p < ports.length; ++p) {
+                for (let p = 0; p < ports.length; ++p) {
                     local.ports.push(ports[p])
                 }
 
                 local.ports.sort();
 
                 ++local.b;
-                addBundlePorts(local.b);
-                
+                addBundlePorts(local.b, done);
+
             });
-            
-            
+
+
 
 
         } else {
-            console.error('[ '+ bundle+' ] is not a valid bundle name')
-            process.exit(1)
+            // console.error('[ '+ bundle+' ] is not a valid bundle name')
+            // process.exit(1)
+            return done( new Error('[ '+ bundle+' ] is not a valid bundle name'))
+        }
+    }
+
+    /**
+     * addBundleToManifest
+     * Add / update project manifest
+     *
+     *
+     * @param {number} b - Bundle index
+     * @callback done
+     *  @param {object|bool} err
+     *  @param {array} ports
+     */
+    var addBundleToManifest = function(data, b, done) {
+
+        loadAssets();
+
+        if ( typeof(data) == 'undefined' || !data ) {
+            data = JSON.clone(self.projectData);
+        }
+
+        if (b > self.bundles.length-1) { // writing to files on complete
+
+            lib.generator.createFileFromDataSync(data, self.projectManifestPath);
+
+            return done(false);
+        }
+
+
+
+        var bundle = self.bundles[b];
+
+        if ( /^[a-z0-9_.]/.test(bundle) ) {
+
+            local.b             = b;
+            local.bundle        = bundle;
+
+
+            var version = '0.0.1';
+            var envs    = self.projects[self.projectName].envs;
+            data.bundles[local.bundle] = {
+                "_comment" : "Your comment goes here.",
+                "version"   : version,
+                "tag" : ( version.split('.') ).join(''),
+                "src" : "src/" + local.bundle,
+                "link"      : "bundles/"+ local.bundle,
+                "releases" : {}
+            };
+            //"release/"+ local.bundle +"/prod/" + version
+            for (let i = 0, len = envs.length; i < len; ++i) {
+                let env = envs[i];
+                // ignore target for dev env
+                if ( self.projects[self.projectName]['dev_env'] == env ) {
+                    continue;
+                }
+                if ( typeof(data.bundles[local.bundle].releases[env]) == 'undefined' ) {
+                    data.bundles[local.bundle].releases[env] = {}
+                }
+                data.bundles[local.bundle].releases[env].target = "releases/"+ local.bundle +"/"+ env +"/" + version;
+            }
+
+            ++local.b;
+            addBundleToManifest(data, local.b, done);
+
+        } else {
+            // console.error('[ '+ bundle+' ] is not a valid bundle name')
+            // process.exit(1)
+            return done( new Error('[ '+ bundle+' ] is not a valid bundle name'))
         }
     }
 
@@ -507,7 +693,8 @@ function Add(opt, cmd) {
 
         npm.setOptions({ chdir: self.projectLocation });
         npm
-            .run('npm link gina', true)
+            // .run('npm link gina', true)
+            .run('gina link @'+ self.projectName, true)
             .onComplete(function (err, data) {
                 if (err) {
                     if ( typeof(onSuccess) != 'undefined' ) {