Upload to GitHub

Author: billsmith37

README.md

@@ -0,0 +1 @@
+### c9launcher

cloud9.js

@@ -0,0 +1,59 @@
+module.exports = function (config, db) {
+    const fs = require('fs');
+    const path = require('path');
+    const { exec } = require('child_process');
+    const kill = require('tree-kill');
+    const isPortAvailable = require('is-port-available');
+    const { getPortPromise } = require('portfinder');
+    
+    class Cloud9 {
+        constructor(executable,wsd) {
+            this._executable = path.resolve(executable);
+            this._wsd = path.resolve(wsd);
+            this._workspaces = fs.readdirSync(this._wsd);
+            this._children = {};
+        }
+        
+        execute(args = []) {
+            const child = exec(`node "${this._executable}" ${args.join(' ')}`);
+            return child;
+        }
+        
+        start(id, workspace, port, auth, collab = false, localOnly = false) {
+            return new Promise(async (resolve,reject) => {
+                if (port == false || port == 0) {
+                    port = await getPortPromise();
+                }
+                if (!await isPortAvailable(port)) return reject('Port is not available');
+                if (!this._workspaces.includes(workspace)) return reject('Workspace not found');
+                var args = [
+                   `-p ${port}`,
+                   `-w "${path.resolve(this._wsd,workspace)}"`,
+                  (collab ? '--collab' : ''),
+                  (localOnly ? '--listen localhost' : ''),
+                  (auth && auth.username && auth.password ? `-a ${auth.username}:${auth.password}` : '')
+                ];
+                var child = this.execute(args);
+                this._children[id] = {child: child, port: port};
+                resolve(child);
+            });
+        }
+        
+        kill(id) {
+            var child = this.getChild(id).child;
+            if (!child) return false;
+            if (child.killed) return false;
+            kill(child.pid);
+            delete this._children[id];
+            return true;
+        }
+        
+        getChild(id) {
+            return id in this._children ? this._children[id] : false;
+        }
+    }
+    
+    return function (executable,wsd) {
+        return new Cloud9(executable,wsd);
+    }
+}

db.js

@@ -0,0 +1,142 @@
+module.exports = async function (config,cryptr) {
+    return new Promise((resolve,reject) => {
+        const bcrypt = require('bcrypt');
+        const deasync = require('deasync');
+        const sqlite3 = require('sqlite3po');
+        const db = new sqlite3.Database(config.database);
+        
+        class User {
+            constructor(first,second,third = 0,fourth = 0) {
+                if (first == undefined) return;
+                if (first % 1 === 0) {
+                    this._id = first;
+                    this._username = second;
+                    this._password = third;
+                    this._admin = fourth;
+                } else {
+                    this._username = first;
+                    this._password = second;
+                    this._admin = third;
+                }
+            }
+            
+            deserialize(row) {
+                return new this.constructor(row.id,row.username,row.password,row.admin);
+            }
+            
+            get asObject() {
+                var obj = {
+                    username: this._username,
+                    password: this._password,
+                    admin: this._admin
+                };
+                if (this._id) obj.id = this._id;
+                return obj;
+            }
+            
+            setPassword(password) {
+                var hash = deasync(bcrypt.hash);
+                this._password = hash(password, 10);
+            }
+            
+            checkPassword(password) {
+                return new Promise((resolve,reject) => {
+                    bcrypt.compare(password,this._password).then(correct => {
+                       resolve(correct);
+                    });  
+                })
+            }
+            
+            serialize() {
+                if (this._id) {
+                    return {
+                        id: this._id,
+                        username: this._username,
+                        password: this._password,
+                        admin: this._admin
+                    }
+                } else {
+                    var hash = deasync(bcrypt.hash);
+                    
+                    this._password = hash(this._password, 10);
+                    
+                    return {
+                        username: this._username,
+                        password: this._password,
+                        admin: this._admin
+                    }
+                }
+            }
+        }
+        
+        class Config {
+            constructor(id,key,value) {
+                this._id = id;
+                this._key = key;
+                this._value = value;
+            }
+            
+            deserialize(row) {
+                return new this.constructor(row.id,row.key,row.value);
+            }
+            
+            serialize() {
+                return {
+                    id: this._id,
+                    key: this._key,
+                    value: this._value
+                }
+            }
+        }
+        
+        class Workspace {
+            constructor(id,key,workspace,port,username,password) {
+                this._id = id;
+                this._key = key;
+                this._workspace = workspace;
+                this._port = port;
+                this._username = username;
+                this._password = password;
+            }
+            deserialize(row) {
+                return new this.constructor(row.id,row.key,row.workspace,row.port,row.username,cryptr.decrypt(row.password));
+            }
+            serialize() {
+                return {
+                    id: this._id,
+                    key: this._key,
+                    workspace: this._workspace,
+                    port: this._port,
+                    username: this._username,
+                    password: cryptr.encrypt(this._password)
+                }
+            }
+        }
+        
+        db.on('open', () => {
+            db.bindSchema(User,'users',{id:'INTEGER PRIMARY KEY AUTOINCREMENT',username: 'TEXT',password: 'TEXT',admin: 'INTEGER'}).then(() => {
+                  User.get('SELECT id FROM users WHERE id = ?',1).then(d => {
+                      if (d == undefined) {
+                          new User('admin','admin',1).save().then(() => {
+                             console.log('Initialized Admin account with username and password as admin.');
+                          });
+                      }
+                  });
+            });
+            db.bindSchema(Config,'config',{id:'INTEGER PRIMARY KEY AUTOINCREMENT',key: 'TEXT', value: 'TEXT'}).then(() => {
+               Config.get('SELECT * FROM config WHERE key = ?','Workspace Directory').then(d => {
+                   if (d == undefined) {
+                       new Config(1,'Workspace Directory','./workspaces').save().then(() => {
+                          console.log('Set config for Server Directory');
+                          new Config(2,'Admins Only','false').save().then(() => {
+                             console.log('Set config for Admins Only');
+                          });
+                       });
+                   }
+               });
+            });
+            db.bindSchema(Workspace,'workspaces',{id:'INTEGER PRIMARY KEY AUTOINCREMENT',key: 'TEXT',workspace: 'TEXT',port: 'INTEGER',username: 'TEXT',password: 'TEXT'}).then();
+            resolve({User: User, Config: Config, Workspace: Workspace});
+        });
+    });
+};

index.js

@@ -0,0 +1,65 @@
+const http       = require('http');
+const express    = require('express');
+const bodyParser = require('body-parser');
+const helmet     = require('helmet');
+const session    = require('express-session');
+const store      = require('connect-sqlite3')(session);
+const deasync    = require('deasync');
+const app        = express();
+const server     = http.createServer(app);
+const Cryptr     = require('cryptr');
+const path       = require('path');
+const port       = process.env.PORT || 8080;
+const ip         = process.env.IP || '0.0.0.0';
+const config     = require('./config.json');
+const cryptr     = new Cryptr(config.crypto);
+const database   = require('./db.js')(config,cryptr);
+database.then(async db => {
+    const cloud9     = require('./cloud9')(config,db);
+    const c9         = cloud9(path.resolve('/home/c9/c9sdk/','server.js'),(await db.Config.get('SELECT * FROM config WHERE key = ?','Workspace Directory'))._value);
+    const proxy      = require('http-proxy').createProxyServer({ws:true});
+    const fs         = require('fs');
+    
+    // Start a workspace named Testing, with the folder as test, port as 8083, and collaboration enabled, then output to console
+    // var workspace = c9.start('Testing','test',8083,{username: 'sirhypernova', password: 'test'},true);
+    // Same as above, but first open port
+    // var workspace = c9.start('Testing','test',false,{username: 'sirhypernova', password: 'test'},true);
+    // workspace.then((child) => {
+    //     child.stdout.pipe(process.stdout);
+    // }).catch(err => {
+    //   console.log(err);
+    // });
+    
+    app.set('view engine', 'ejs');
+    
+    // Helmet
+    app.use(helmet());
+    // Session
+    app.use(session({
+        store: new store({
+            db: config.session
+        }),
+        name: 'rvsess',
+        resave: true,
+        saveUninitialized: false,
+        secret: '3348227453261949266283369121938267059251'
+    }));
+    
+    // Initialize Routes
+    
+    require('./routes')(app,config,db,proxy,c9,cryptr)(config.routes).then(() => {
+        console.log('Loaded routes successfully.');
+        
+        // Register 404 Page
+        app.use((req,res) => {
+           res.render('404',{name: config.name, page: '404'});
+        });
+        
+        // Configure static directory
+        app.use(express.static('static'));
+    });
+    
+    app.listen(port,ip, () => {
+       console.log(`Server listening at ${ip}:${port}`);
+    }); 
+});