@kumologica/sdk 3.0.0

package/src/app/ui/editor-api/lib/editor/theme.js

@@ -0,0 +1,184 @@
+ 
+
+var express = require('express');
+var util = require('util');
+var path = require('path');
+var fs = require('fs');
+var clone = require('clone');
+
+var defaultContext = {
+  page: {
+    title: 'kumologica-core1',
+    favicon: 'favicon.ico',
+    tabicon: 'red/images/kumologica-core-icon-black.svg'
+  },
+  header: {
+    title: 'kumologica-core2',
+    image: 'red/images/kumologica-core.png'
+  },
+  asset: {
+    red:
+      process.env.NODE_ENV == 'development' ? 'red/red.js' : 'red/red.min.js',
+    main:
+      process.env.NODE_ENV == 'development' ? 'red/main.js' : 'red/main.min.js'
+  }
+};
+
+var theme = null;
+var themeContext = clone(defaultContext);
+var themeSettings = null;
+
+var themeApp;
+
+function serveFile(app, baseUrl, file) {
+  try {
+    var stats = fs.statSync(file);
+    var url = baseUrl + path.basename(file);
+    //console.log(url,"->",file);
+    app.get(url, function(req, res) {
+      res.sendFile(file);
+    });
+    return 'theme' + url;
+  } catch (err) {
+    //TODO: log filenotfound
+    return null;
+  }
+}
+
+function serveFilesFromTheme(themeValue, themeApp, directory) {
+  var result = [];
+  if (themeValue) {
+    var array = themeValue;
+    if (!util.isArray(array)) {
+      array = [array];
+    }
+
+    for (var i = 0; i < array.length; i++) {
+      var url = serveFile(themeApp, directory, array[i]);
+      if (url) {
+        result.push(url);
+      }
+    }
+  }
+  return result;
+}
+
+module.exports = {
+  init: function(settings) {
+    themeContext = clone(defaultContext);
+    themeSettings = null;
+    theme = settings.editorTheme || {};
+  },
+
+  app: function() {
+    var i;
+    var url;
+    themeSettings = {};
+
+    themeApp = express();
+
+    if (theme.page) {
+      themeContext.page.css = serveFilesFromTheme(
+        theme.page.css,
+        themeApp,
+        '/css/'
+      );
+      themeContext.page.scripts = serveFilesFromTheme(
+        theme.page.scripts,
+        themeApp,
+        '/scripts/'
+      );
+
+      if (theme.page.favicon) {
+        url = serveFile(themeApp, '/favicon/', theme.page.favicon);
+        if (url) {
+          themeContext.page.favicon = url;
+        }
+      }
+
+      if (theme.page.tabicon) {
+        url = serveFile(themeApp, '/tabicon/', theme.page.tabicon);
+        if (url) {
+          themeContext.page.tabicon = url;
+        }
+      }
+
+      themeContext.page.title = theme.page.title || themeContext.page.title;
+    }
+
+    if (theme.header) {
+      themeContext.header.title =
+        theme.header.title || themeContext.header.title;
+
+      if (theme.header.hasOwnProperty('url')) {
+        themeContext.header.url = theme.header.url;
+      }
+
+      if (theme.header.hasOwnProperty('image')) {
+        if (theme.header.image) {
+          url = serveFile(themeApp, '/header/', theme.header.image);
+          if (url) {
+            themeContext.header.image = url;
+          }
+        } else {
+          themeContext.header.image = null;
+        }
+      }
+    }
+
+    if (theme.deployButton) {
+      if (theme.deployButton.type == 'simple') {
+        themeSettings.deployButton = {
+          type: 'simple'
+        };
+        if (theme.deployButton.label) {
+          themeSettings.deployButton.label = theme.deployButton.label;
+        }
+        if (theme.deployButton.icon) {
+          url = serveFile(themeApp, '/deploy/', theme.deployButton.icon);
+          if (url) {
+            themeSettings.deployButton.icon = url;
+          }
+        }
+      }
+    }
+
+    if (theme.hasOwnProperty('userMenu')) {
+      themeSettings.userMenu = theme.userMenu;
+    }
+
+    if (theme.login) {
+      if (theme.login.image) {
+        url = serveFile(themeApp, '/login/', theme.login.image);
+        if (url) {
+          themeContext.login = {
+            image: url
+          };
+        }
+      }
+    }
+
+    if (theme.hasOwnProperty('menu')) {
+      themeSettings.menu = theme.menu;
+    }
+
+    if (theme.hasOwnProperty('palette')) {
+      themeSettings.palette = theme.palette;
+    }
+
+    if (theme.hasOwnProperty('projects')) {
+      themeSettings.projects = theme.projects;
+    }
+
+    return themeApp;
+  },
+  context: function() {
+    return themeContext;
+  },
+  settings: function() {
+    return themeSettings;
+  },
+  serveFile: function(baseUrl, file) {
+    return serveFile(themeApp, baseUrl, file);
+  }
+};

package/src/app/ui/editor-api/lib/editor/ui.js

@@ -0,0 +1,149 @@
+var express = require('express');
+var fs = require('fs');
+var path = require('path');
+var Mustache = require('mustache');
+var mime = require('mime');
+
+var apiUtils = require('../util');
+
+var theme = require('./theme');
+
+var runtimeAPI;
+var editorClientDir = path.dirname(require.resolve('../../../editor-client'));
+var defaultNodeIcon = path.join(
+  editorClientDir,
+  'public',
+  'red',
+  'images',
+  'icons',
+  'arrow-in.png'
+);
+
+// Editor main page
+let editorTemplatePath = path.join(editorClientDir, 'templates', 'index.mst');
+let editorTemplate;
+
+// Modal for home screen
+let modalHomeTemplatePath = path.join(
+  editorClientDir,
+  'templates',
+  'modals',
+  'modalHome.mst'
+);
+let modalHomeTemplate;
+
+// Modal for welcome screen
+let modalWelcomeTemplatePath = path.join(
+  editorClientDir,
+  'templates',
+  'modals',
+  'modalWelcome.mst'
+);
+let modalWelcomeTemplate;
+
+// Modal for open new projects
+let modalNewProjectTemplatePath = path.join(
+  editorClientDir,
+  'templates',
+  'modals',
+  'modalNewProject.mst'
+);
+let modalNewProjectTemplate;
+
+// Modal for library nodes
+let modalNodeLibraryPath = path.join(
+  editorClientDir,
+  'templates',
+  'modals',
+  'modalNodeLibrary.mst'
+);
+let modalNodeLibraryTemplate;
+
+module.exports = {
+  init: function(_runtimeAPI) {
+    runtimeAPI = _runtimeAPI;
+
+    // Parse the editor page
+    editorTemplate = fs.readFileSync(editorTemplatePath, 'utf8');
+    Mustache.parse(editorTemplate);
+
+    // Parse the home modal page
+    modalHomeTemplate = fs.readFileSync(modalHomeTemplatePath, 'utf8');
+    Mustache.parse(modalHomeTemplate);
+
+    // Parse the welcome modal page
+    modalWelcomeTemplate = fs.readFileSync(modalWelcomeTemplatePath, 'utf8');
+    Mustache.parse(modalWelcomeTemplate);
+
+    // Parse the modalNewProject page
+    modalNewProjectTemplate = fs.readFileSync(
+      modalNewProjectTemplatePath,
+      'utf8'
+    );
+    Mustache.parse(modalNewProjectTemplate);
+
+    // Parse the modalNodeLibary page
+    modalNodeLibraryTemplate = fs.readFileSync(modalNodeLibraryPath, 'utf8');
+    Mustache.parse(modalNodeLibraryTemplate);
+  },
+
+  ensureSlash: function(req, res, next) {
+    var parts = req.originalUrl.split('?');
+    if (parts[0].slice(-1) != '/') {
+      parts[0] += '/';
+      var redirect = parts.join('?');
+      res.redirect(301, redirect);
+    } else {
+      next();
+    }
+  },
+  icon: function(req, res) {
+    var icon = req.params.icon;
+    var scope = req.params.scope;
+    var module = scope ? scope + '/' + req.params.module : req.params.module;
+    var opts = {
+      user: req.user,
+      module: module,
+      icon: icon
+    };
+    runtimeAPI.nodes
+      .getIcon(opts)
+      .then(function(data) {
+        if (data) {
+          var contentType = mime.getType(icon);
+          res.set('Content-Type', contentType);
+          res.send(data);
+        } else {
+          res.sendFile(defaultNodeIcon);
+        }
+      })
+      .catch(function(err) {
+        console.log(err.stack);
+        apiUtils.rejectHandler(req, res, err);
+      });
+  },
+
+  editor: function(req, res) {
+    res.send(Mustache.render(editorTemplate, theme.context()));
+  },
+
+  // important: the suffix after modal must be the same as path in url,
+  // for example /newProject will use modalNewProject
+  //  not sure why /home maps to modalHomePage
+  modalNewProject: function(req, res) {
+    res.send(Mustache.render(modalNewProjectTemplate, theme.context()));
+  },
+  modalHomePage: function(req, res) {
+    res.send(Mustache.render(modalHomeTemplate, theme.context()));
+  },
+
+  modalWelcomePage: function(req, res) {
+    res.send(Mustache.render(modalWelcomeTemplate, theme.context()));
+  },
+
+  modalNodeLibrary: function(req, res) {
+    res.send(Mustache.render(modalNodeLibraryTemplate, theme.context()));
+  },
+
+  editorResources: express.static(path.join(editorClientDir, 'public'))
+};

package/src/app/ui/editor-api/lib/index.js

@@ -0,0 +1,149 @@
+ 
+
+/**
+ * This module provides an Express application to serve the kumologica-core editor.
+ *
+ * It implements the kumologica-core HTTP Admin API the Editor uses to interact
+ * with the kumologica-core runtime.
+ *
+ * @namespace @kumologica-core/editor-api
+ */
+
+var express = require('express');
+var bodyParser = require('body-parser');
+var util = require('util');
+var passport = require('passport');
+var when = require('when');
+var cors = require('cors');
+
+var auth = require('./auth');
+var apiUtil = require('./util');
+
+var adminApp;
+var server;
+var editor;
+let settings;
+
+/**
+ * Initialise the module.
+ * @param  {Object}     settings   The runtime settings
+ * @param  {HTTPServer} server     An instance of HTTP Server
+ * @param  {Storage}    storage    An instance of kumologica-core Storage
+ * @param  {Runtime}    runtimeAPI An instance of kumologica-core Runtime
+ * @memberof @kumologica-core/editor-api
+ */
+function init(userSettings, _server, storage, runtimeAPI) {
+  settings = userSettings;
+  server = _server;
+  if (settings.httpAdminRoot !== false) {
+    adminApp = express();
+
+    var cors = require('cors');
+    var corsHandler = cors({
+      origin: '*',
+      methods: 'GET,PUT,POST,DELETE'
+    });
+    adminApp.use(corsHandler);
+
+    auth.init(settings, storage);
+
+    var maxApiRequestSize = settings.apiMaxLength || '5mb';
+    adminApp.use(bodyParser.json({ limit: maxApiRequestSize }));
+    adminApp.use(
+      bodyParser.urlencoded({ limit: maxApiRequestSize, extended: true })
+    );
+
+    adminApp.get('/auth/login', auth.login, apiUtil.errorHandler);
+    if (settings.adminAuth) {
+      if (settings.adminAuth.type === 'strategy') {
+        auth.genericStrategy(adminApp, settings.adminAuth.strategy);
+      } else if (settings.adminAuth.type === 'credentials') {
+        adminApp.use(passport.initialize());
+        adminApp.post(
+          '/auth/token',
+          auth.ensureClientSecret,
+          auth.authenticateClient,
+          auth.getToken,
+          auth.errorHandler
+        );
+      }
+      adminApp.post(
+        '/auth/revoke',
+        auth.needsPermission(''),
+        auth.revoke,
+        apiUtil.errorHandler
+      );
+    }
+
+    // Editor
+    if (!settings.disableEditor) {
+      editor = require('./editor');
+      var editorApp = editor.init(server, settings, runtimeAPI);
+      adminApp.use(editorApp);
+    }
+
+    if (settings.httpAdminCors) {
+      var corsHandler = cors(settings.httpAdminCors);
+      adminApp.use(corsHandler);
+    }
+
+    var adminApiApp = require('./admin').init(runtimeAPI);
+    adminApp.use(adminApiApp);
+  } else {
+    adminApp = null;
+  }
+}
+
+/**
+ * Start the module.
+ * @return {Promise} resolves when the application is ready to handle requests
+ * @memberof @kumologica-core/editor-api
+ */
+function start() {
+  if (editor) {
+    return editor.start();
+  } else {
+    return when.resolve();
+  }
+}
+
+/**
+ * Stop the module.
+ * @return {Promise} resolves when the application is stopped
+ * @memberof @kumologica-core/editor-api
+ */
+function stop() {
+  if (editor) {
+    editor.stop();
+  }
+  return when.resolve();
+}
+module.exports = {
+  init: init,
+  start: start,
+  stop: stop,
+
+  /**
+   * @memberof @kumologica-core/editor-api
+   * @mixes @kumologica-core/editor-api_auth
+   */
+  auth: {
+    needsPermission: auth.needsPermission
+  },
+  /**
+   * The Express app used to serve the kumologica-core Editor
+   * @type ExpressApplication
+   * @memberof @kumologica-core/editor-api
+   */
+  get httpAdmin() {
+    return adminApp;
+  },
+
+  /**
+   * The runtime settings used to initialize the editorAPI
+   * @returns {object} settings object
+   */
+  get userSettings() {
+    return settings;
+  }
+};

package/src/app/ui/editor-api/lib/runner/index.js

@@ -0,0 +1,81 @@
+let runner = (function() {
+  /**
+   *
+   * @param {string} executableFile - absolute path to the file to execute
+   * @param {any[]} executableParams - arguments to the executable
+   * @param {object} env  = {'KEY': 'VALUE', 'KEY2':'VALUE2' }
+   */
+  function execute(type, name, executableFile, executableParams, env) {
+    // Lazy loading dependencies
+    const { fork, execFile } = require('child_process');
+
+    // const options = {
+    //   env: env || {},
+    //   stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+    //   execArgv: ['--harmony']
+    // };
+
+    options = {
+      env: env,
+      shell: true
+    };
+
+    const child = execFile(executableFile, executableParams, options);
+    const em = window.__kumologica.editor.terminal.eventEmitter;
+    child.stdout.on('data', data => {
+      let msg = decodeMessageFromChild(data);
+
+      let lines = msg.split('\n');
+      lines.forEach(line => {
+        //window.__kumologica.editor.terminal.writeln(line);
+        em.emit('terminal-output', line);
+      });
+    });
+
+    child.stderr.on('data', data => {
+      let msg = decodeMessageFromChild(data);
+      let lines = msg.split('\n');
+      lines.forEach(line => {
+        // window.__kumologica.editor.terminal.writeln(
+        //   '\x1B[1;3;31m' + line + '\x1B[0m'
+        // );
+        em.emit('terminal-output', '\x1B[1;3;31m' + line + '\x1B[0m');
+      });
+    });
+
+    child.on('exit', function(code, signal) {
+      // window.__kumologica.editor.terminal.writeln(
+      //   `"${name}" exited with code: ${code}`
+      // );
+      em.emit('terminal-output', `"${name}" exited with code: ${code}`);
+      // console.log(`Script: ${name} exited. Code: ${code} `);
+
+      let displayMessage;
+      if (code === 0) {
+        displayMessage = 'Completed successfully';
+      } else {
+        displayMessage = 'Completed with errors. See console for more details';
+      }
+      let myNotification = new window.__kumologica.electron.remote.Notification(
+        {
+          title: `${name}`,
+          subtitle: `${displayMessage}`
+        }
+      );
+
+      myNotification.show();
+    });
+  }
+
+  function decodeMessageFromChild(data) {
+    let StringDecoder = require('string_decoder').StringDecoder;
+    let decoder = new StringDecoder('utf8');
+    return decoder.write(data);
+  }
+
+  return {
+    execute: execute
+  };
+})();
+
+module.exports = runner.execute;

package/src/app/ui/editor-api/lib/util.js

@@ -0,0 +1,51 @@
+ 
+
+const { util: runtimeUtil } = require('../../../lib/runtime-loader');
+const log = runtimeUtil.log;
+
+module.exports = {
+  errorHandler: function(err, req, res, next) {
+    //TODO: why this when rejectHandler also?!
+
+    if (err.message === 'request entity too large') {
+      log.error(err);
+    } else {
+      log.error(err.stack);
+    }
+    log.audit(
+      {
+        event: 'api.error',
+        error: err.code || 'unexpected_error',
+        message: err.toString()
+      },
+      req
+    );
+    res
+      .status(400)
+      .json({ error: 'unexpected_error', message: err.toString() });
+  },
+
+  determineLangFromHeaders: function(acceptedLanguages) {
+    var lang = 'en-US';
+    acceptedLanguages = acceptedLanguages || [];
+    if (acceptedLanguages.length >= 1) {
+      lang = acceptedLanguages[0];
+    }
+    return lang;
+  },
+  rejectHandler: function(req, res, err) {
+    //TODO: why this when errorHandler also?!
+    log.audit(
+      {
+        event: 'api.error',
+        error: err.code || 'unexpected_error',
+        message: err.message || err.toString()
+      },
+      req
+    );
+    res.status(err.status || 400).json({
+      code: err.code || 'unexpected_error',
+      message: err.message || err.toString()
+    });
+  }
+};

package/src/app/ui/editor-client/README.md

@@ -0,0 +1,10 @@
+@kumologica-core/editor-client
+====================
+
+kumologica-core editor resources module.
+
+This provides all of the client-side resources of the kumologica-core editor application.
+
+### Source
+
+The main kumologica-core modules are maintained as a monorepo on [GitHub](https://github.com/kumologica-core/kumologica-core).

package/src/app/ui/editor-client/constants.js

@@ -0,0 +1,5 @@
+const KUMOLOGICA_CORE_MODULE = 'kumologica-core';
+
+module.exports = {
+  KUMOLOGICA_CORE_MODULE
+};

package/src/app/ui/editor-client/index.js

@@ -0,0 +1,3 @@
+ 
+
+module.exports = false