Develop

Cognitavit/.gitignore

@@ -17,10 +17,14 @@ node_modules
 
 __pycache__
 venv
+.venv
 
 # OSX
 .DS_Store
 
+build/
+dist/
+
 release/app/dist
 release/build
 .erb/dll

Cognitavit/package.json

@@ -78,24 +78,37 @@
     }
   },
   "dependencies": {
+    "@emotion/react": "^11.10.0",
+    "@emotion/styled": "^11.10.0",
+    "@mui/material": "^5.9.3",
+    "@reduxjs/toolkit": "^1.8.3",
     "axios": "^0.27.2",
+    "bootstrap": "^5.2.0",
     "electron-debug": "^3.2.0",
     "electron-log": "^4.4.7",
+    "electron-store": "^8.0.2",
     "electron-updater": "^5.0.1",
     "i": "^0.3.7",
+    "node-machine-id": "^1.1.12",
     "react": "^18.1.0",
+    "react-bootstrap": "^2.4.0",
     "react-dom": "^18.1.0",
+    "react-redux": "^8.0.2",
     "react-router-dom": "^6.3.0",
     "react-scripts": "^2.1.3",
-    "react-toastify": "^9.0.5"
+    "react-spinners": "^0.13.3",
+    "react-toastify": "^9.0.5",
+    "redux": "^4.2.0",
+    "socket.io": "^4.5.1",
+    "socket.io-client": "^4.5.1"
   },
   "devDependencies": {
     "@pmmmwh/react-refresh-webpack-plugin": "^0.5.6",
     "@teamsupercell/typings-for-css-modules-loader": "^2.5.1",
     "@testing-library/jest-dom": "^5.16.4",
     "@testing-library/react": "^13.2.0",
     "@types/jest": "^27.5.1",
-    "@types/node": "17.0.33",
+    "@types/node": "^17.0.33",
     "@types/react": "^18.0.9",
     "@types/react-dom": "^18.0.4",
     "@types/react-test-renderer": "^18.0.0",

Cognitavit/src/executor/core.py

@@ -1,63 +1,98 @@
-from time import sleep
-from execFactory import FactoryExecutor
+'''
+python-electron executor
+A tool used to read applet list and execute applications based on name or applet id. 
 
+-
+This app lifecycle is managed by electron.
+Upon startup the follow enviroment variables are set.
 
-def print_list(list):
-    for item in list:
-        print(item + " " + list[item])
+APPDATA = "path_to_save_data/<userid>/
+ie: the path will look like this  -> C:/path_to_shared_secret/cognitavit/userid/
 
+inside the userid folder we have the following 
 
-#Create factory executor
-execute_factory = FactoryExecutor()
-#Return an executor object
-platform_exec = execute_factory.create('win')
-dev = platform_exec.read_native_app_list()
-#  def native_exec(self, name:str, params:str, exec_app_list:Tuple[dict,dict], app_type:int) -> AppStatus:
+Folder content:
+/orchestra_webapps: A folder which consists of shortcuts to the actual binaries. [Located in the download folder] 
+/custom_binaries: A folder which consits of shortcut to bots detail. [Located in random place in drive. (which is why its a shortcut)]
+/downloads: A place where downloaded items are stored.  
+web_app.config: config file of what orchestra web bots are installed.
 
-print_list(dev[0])
-print("End of dev0 list")
+You may assume that you are already inside the userid/ folder
 
-print_list(dev[1])
-print("End of dev1 list")
+'''
 
+from platform import platform
+from flask import Flask, request, jsonify
+from flask_socketio import SocketIO, emit
 
+import json, os, signal
 
-#test a system command
-#ps = platform_exec.native_exec("terminal", r" 'shutdown', '/s' ", dev, 0)
-#sleep(3)
+from engineio.async_drivers import threading
 
-#Regular App
-ps = platform_exec.native_exec("chrome", r"https://www.youtube.com/watch?v=dQw4w9WgXcQ", dev, 0)
-sleep(3)
 
-#Windows Store App
 
-ps = platform_exec.native_exec("notepad", r"C:\Users\Seron\Desktop\test.txt", dev, 0)
-sleep(3)
-#Windows Store App
-ps = platform_exec.native_exec("player", r"C:\Users\Seron\Desktop\pro_battles.177886dc.mp3", dev, 0)
-sleep(3)
+import requests
+import sys
+#Import Routes from network 
+from network.readApplication import read_app as readApplication
+from network.execApplication import exec_app as execApplication
+from network.downloadApplication import download_app as downloadApplication
+from network.downloadApplication import download_and_install
+# To read the enviroment variables
 
-#Windows Store App
-ps = platform_exec.native_exec("clock", r"", dev, 0)
-sleep(3)
 
-#Installed App
-ps = platform_exec.native_exec("discord", r"", dev, 0)
-sleep(3)
+port_start = 5000
 
+AUTHENiCATION_OBJECT = None
+USER_DATA_PATH = None
+PlATFORM_START = None
+DEVICE_ID = None
 
-#Installed App
-ps = platform_exec.native_exec("edge", r"", dev, 0)
-sleep(3)
+if sys.argv.__len__() > 1:
+    try:
+        AUTHENiCATION_OBJECT = sys.argv[1]
+    except:
+        print("failed to read json object")
+    USER_DATA_PATH = sys.argv[2]
+    PlATFORM_START = sys.argv[3]
+    DEVICE_ID = sys.argv[4]
 
-#test a system command
-ps = platform_exec.native_exec("terminal", r" 'shutdown', '/s' ", dev, 0)
-sleep(3)
 
-#cancel the restart
-ps = platform_exec.native_exec("terminal", r" 'shutdown', '-a' ", dev, 0)
+app = Flask(__name__)
+socketio = SocketIO(
+            app,
+            async_mode="threading"
+        )
 
 
-print(ps)
+app.register_blueprint(readApplication)
+app.register_blueprint(execApplication)
+app.register_blueprint(downloadApplication)
 
+# Import Application flags
+
+@app.route('/is_alive', methods=['POST'])
+def alive():
+    return {"status": True}
+
+
+@app.route('/kill', methods=['POST'])
+def kill():
+    os.kill(os.getpid(), signal.SIGINT)
+
+@app.route('/enviroment', methods=['POST'])
+def enviroment():
+    return str([AUTHENiCATION_OBJECT, USER_DATA_PATH, PlATFORM_START])
+
+@socketio.event
+def connect():
+    print("I'm connected!")
+
+@socketio.event
+def disconnect():
+    print("Cognitavit disconnected. Im gonna die now.")
+    os.kill(os.getpid(), signal.SIGINT)
+
+if __name__ == '__main__':
+    download_and_install()
+    socketio.run(app,host="0.0.0.0", port=port_start,debug=True)

Cognitavit/src/executor/core.spec

@@ -0,0 +1,44 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+
+block_cipher = None
+
+
+a = Analysis(
+    ['core.py'],
+    pathex=[],
+    binaries=[],
+    datas=[],
+    hiddenimports=['engineio.async_drivers.eventlet'],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+    noarchive=False,
+)
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    [],
+    name='core',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

Cognitavit/src/executor/device_executor/exec.py

@@ -1,4 +1,17 @@
 from abc import ABC, abstractclassmethod
+import subprocess
+import os, sys
+from os import path
+import json
+
+AUTHENiCATION_OBJECT = sys.argv[1]
+USER_DATA_PATH = sys.argv[2]
+DEVICE_ID = sys.argv[4]
+userId = AUTHENiCATION_OBJECT
+env_userpath = USER_DATA_PATH
+CONFIG_NAME = "installed.json"
+config_file = path.join(env_userpath, CONFIG_NAME)
+
 
 class Executor(ABC):
 
@@ -20,7 +33,24 @@ def native_exec(self, name:str, params:str, applist:dict) -> None:
         '''Executes a native application with optional launch params'''
 
     @abstractclassmethod
-    def bot_exec(self, params:str) ->None:
-        '''Executes a bot application from the orchestra webstore'''
+    def execute(self, name:str, params:str) ->None:
+        '''Wrapper for native_exec'''
+
+
+    def bot_exec(self, buid:str, args:str):
+        if (os.path.exists(config_file) == True):
+            with open(config_file) as f:
+                data = json.load(f)
+
+            for bot in data["installed"]:
+                if bot["buid"] == buid:
+                    path = bot["path"]
+                    args = args.split() + [path] 
+                    #return {"to_run": args}
+                    output = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
+                    outdata = output.stdout.read()
+                    print(outdata, file=sys.stderr)
+                    return {"result": outdata}
+
 
 

Cognitavit/src/executor/device_executor/exec_linux.py

@@ -1,32 +1,74 @@
 
 from device_executor.exec import Executor
 import subprocess, os, json
+from typing import Tuple
+
+from AppStatus import  AppStatus
 
 ERROR = 0
 OUTPUT = 1
 
+# Application Binary classification
+APPLICATION_LIST = 0 # Regular program [Assume properly registered to start menu]
+FALLBACK_LIST = 1 # Regular program + Windows Store Apps [Hidden]
+
 class LinuxExecutor(Executor):
-
 
     def read_native_app_list(self) -> dict:
         ''' Returns a list of apps natively installed apps on this machine, alongside the appid.
-
         On success returns a list as {"appname1": "appid1", "appname2": "appid2", "appname3", "appid3"}
         Otherwises returns a errorcode
         '''
-        return {}
-
+        fall_back_list = {}
+        # echo '"""{' && find /usr/bin -type f -printf '"%P" : "%p"\n' && echo '}"""'
+        # echo "\"\"\"{" && find /usr/bin -type f -printf "\"%P\" : \"%p\"\n" && echo "}\"\"\""
+        c = 'find /usr/bin -type f -printf \"\\"%P\\" : \\"%p\\", \"'
+        rnc = subprocess.check_output(c, shell=True)
+        if (len(rnc)): return [json.loads("{" + (rnc.decode('utf-8'))[:-2] + "}"), fall_back_list]
+        else: return [{}, fall_back_list]
 
     def read_orchestra_app_list(self) -> dict:
         ''' Returns a list of currently installed bots from the orchestra web store on this machine
             along side the binary location. The directory is stored in the userapp storage as a json file.
         '''
         return {}
 
-    def native_exec(self, name:str, params:str, applist: dict) -> None:
+
+
+
+
+    def locate_binary(self, name:str, exec_app_list):
+        '''Returns -1 if binary name cannot be located in app_list. Otherwise return tuple of
+        appname, and binary location.
+        Works by doing a char match. name is defined from exec_app_list at earlier point in time.
+        '''
+        print("ran")
+        name = name.lower()
+        for app in sorted(exec_app_list,key=len):
+            application_name = app.lower()
+            if (name == application_name):
+                return [app, exec_app_list[app]]
+        return 0
+
+    def native_exec(self, name:str, params:str, exec_app_list:Tuple[dict,dict], app_type:int) -> AppStatus:
         '''Executes a native application with optional launch params'''
-        return
+        ar = self.locate_binary(name, exec_app_list[APPLICATION_LIST]) # app rec
+        if (not ar):
+            ar = self.locate_binary(name, exec_app_list[FALLBACK_LIST])
+            if (not ar):
+                return -1
+        print("Binary located @: " + ar[1])
+        try:
+            c = ar[0]
+            if (len(params)):
+                c += " " + params
+            subprocess.run(c, shell=True)
+            return 1
+        except Exception as e:
+            return -2
 
-    def bot_exec(self, params) -> None:
-        '''Executes a bot application from the orchestra webstore'''
-        return {}
+
+    def execute(self, name:str, params:str) ->None:
+        '''Wrapper for native_exec, user does not pass in exec_app_list, but instead the fxn 
+        will generate using one of its built in functions'''
+        pass

Cognitavit/src/executor/device_executor/exec_mac.py

@@ -27,6 +27,6 @@ def native_exec(self, name:str, params:str, applist: dict) -> None:
         '''Executes a native application with optional launch params'''
         return
 
-    def bot_exec(self, params) -> None:
-        '''Executes a bot application from the orchestra webstore'''
-        return {}
+    def execute(self, name:str, params:str) ->None:
+        '''Wrapper for native_exec'''
+        pass