@makano/rew 1.2.21 → 1.2.31

package/README.md

@@ -31,6 +31,9 @@ in the process.
   ```
   Optionally, you can run single files with `rew [filename]`
 
+## Docs
+You can pay a visit to the [docs](https://kevinj045.github.io/rew-docs/) to learn more about rew and how it works.
+
 ## Author's Notes
 
 Any suggestions, bug fixes or ideas are accepted, feel free to ask anything. 

package/bin/rew

@@ -1,9 +1,2 @@
 #!/usr/bin/env node
-const path = require('path');
-const fs = require('fs');
-const rew_mod = path.resolve(process.cwd(), 'snode_moduless/@makano/rew');
-if(fs.existsSync(rew_mod)){
-  require(path.join(rew_mod, 'lib/rew/cli/cli.js'));
-} else {
-  require('../lib/rew/cli/cli.js');
-}
+require("../lib/rew/cli/cli.js");

package/lib/rew/cli/cli.js

@@ -3,8 +3,7 @@
 const yargs = require('yargs/yargs');
 const path = require('path');
 const { hideBin } = require('yargs/helpers');
-const { fork, exec, execSync } = require('child_process');
-const { watch } = require('chokidar');
+const { execSync } = require('child_process');
 const utils = require('./utils');
 const { existsSync, readFileSync, writeFileSync, mkdirSync } = require('fs');
 const { log } = require('./log');
@@ -16,12 +15,16 @@ const { to_qrew, from_qrew } = require('../qrew/compile');
 const { findAppInfo } = require('../misc/findAppInfo');
 const { print, input } = require('../functions/stdout');
 const colors = require('colors');
+const { req } = require('../misc/req');
+const { gen_key } = require('../misc/bin');
 
-if (!existsSync(CONFIG_PATH)) {
+if (!existsSync(CONFIG_PATH) || !existsSync(CONFIG_PATH+'/repos.yaml')) {
 	mkdirSync(CONFIG_PATH, { recursive: true });
 	utils.initFirst();
 }
 
+const npm_package_name = '@makano/rew';
+
 yargs(hideBin(process.argv))
 	.command(
 		'$0 <file>',
@@ -41,31 +44,10 @@ yargs(hideBin(process.argv))
 		(argv) => {
 			const filePath = path.resolve(process.cwd(), argv.file);
 			if (!existsSync(filePath)) {
-				log('File not found:', argv.file, ':end');
+				log('File not found:'.red.bold, argv.file, ':end');
 				return;
 			}
-			const watching = [];
-			const watchIt = (file) => {
-				if (watching.includes(file)) return;
-				watch(file).on('change', () => runIt());
-				watching.push(file);
-			};
-			let prevFork;
-			const runIt = () => {
-				if (argv.watch) console.clear();
-				if (prevFork && !prevFork.killed) prevFork.kill?.();
-				prevFork = fork(path.resolve(__dirname, './run.js'))
-					.on('message', (data) => {
-						if (argv.watch) {
-							data.forEach((file) => {
-								watchIt(file);
-							});
-						}
-					})
-					.send({ filePath, watch: argv.watch });
-				if (argv.watch) watchIt(filePath);
-			};
-			runIt();
+			utils.runFileWithArgv(filePath, { watch: argv.watch });
 		},
 	)
 	.command(
@@ -122,19 +104,6 @@ yargs(hideBin(process.argv))
 			console.log('Encryption Key:', rune({}).genKey(input('Secret Value: ') || null));
 		},
 	)
-	.command(
-		'ui-bin <path>',
-		'Build the UI bin for your own app',
-		(yargs) => {
-			yargs.positional('path', {
-				describe: 'Path of the output bin',
-				type: 'string',
-			});
-		},
-		(argv) => {
-			execSync('sh ' + path.resolve(__dirname, '../../../build.sh') + ' ' + argv.path);
-		},
-	)
 	.command(
 		'run <path | package>',
 		'Run an app',
@@ -147,6 +116,11 @@ yargs(hideBin(process.argv))
 				describe: 'If your entry file is a .qrew, then just use the .coffee instead',
 				type: 'boolean',
 			})
+			.option('entry', {
+				alias: 'e',
+				describe: 'Choose entry file from app.config.exec',
+				type: 'string',
+			})
 			.option('build', {
 				alias: 'b',
 				describe: 'Builds to a .qrew before running',
@@ -166,30 +140,37 @@ yargs(hideBin(process.argv))
 		'secret <command> [key]',
 		'Add secrets to the current path',
 		(yargs) => {
-			yargs.positional('command', {
+			yargs
+			.positional('command', {
 				describe: 'Path of the app to run',
 				type: 'string',
-			});
+			})
+			.option('file', {
+				alias: 'f',
+				describe: 'Set file name',
+				type: 'string',
+				default: 'secrets.qrew'
+			})
 		},
 		(argv) => {
 			const appPath = findAppInfo(path.join(process.cwd(), 'app.yaml'));
 
 			if (!appPath) return log(''.red.bold, 'Secrets only available in apps'.red.bold, ':end');
 
-			const qrewPath = path.join(appPath.path, 'secrets.qrew');
+			const qrewPath = path.join(appPath.path, argv.file || 'secrets.qrew');
 
-			const getHost = () => `${process.env.USER}@${os.platform()}.${os.hostname()}`;
+			const getPass = () => gen_key(input('Secret Encryptor: '));//`${process.env.USER}@${os.platform()}.${os.hostname()}`;
 
 			const verifyUser = (content) => {
 				const owner = content.match(/^owner = "(.*)" # end$/m)?.[1];
-				if (owner == getHost()) return true;
+				if (owner == getPass()) return true;
 				return false;
 			};
 
 			if (argv.command == 'init') {
-				writeFileSync(qrewPath, to_qrew(`secrets = {} # end\n\nowner = "${getHost()}" # end\n \nexports { ...secrets }`, appPath.config.package))
+				writeFileSync(qrewPath, to_qrew(`secrets = {} # end\n\nowner = "${getPass()}" # end\n \nexports { ...secrets }`, appPath.config.manifest.package))
 			} else {
-				const currentFileContent = from_qrew(readFileSync(qrewPath), appPath.config.package).toString();
+				const currentFileContent = from_qrew(readFileSync(qrewPath), appPath.config.manifest.package).toString();
 				if (!verifyUser(currentFileContent)) return log(''.red.bold, 'You are not allowed to change this data'.red.bold, ':end');
 
 				const secrets = currentFileContent.match(/^secrets = (.*) # end$/m)?.[1];
@@ -208,7 +189,7 @@ yargs(hideBin(process.argv))
 					const newSecrets = `secrets = ${JSON.stringify(secretsJson)} # end`;
 					const newFileContent = currentFileContent.replace(/^secrets = .* # end$/m, newSecrets);
 
-					writeFileSync(qrewPath, to_qrew(newFileContent, appPath.config.package))
+					writeFileSync(qrewPath, to_qrew(newFileContent, appPath.config.manifest.package))
 				} else if (argv.command == 'get') {
 					if (argv.key) {
 						console.log(argv.key.yellow, '=', secretsJson[argv.key].green);
@@ -229,10 +210,15 @@ yargs(hideBin(process.argv))
 			yargs.positional('path', {
 				describe: 'Path or github or repo id of the app to install',
 				type: 'string',
+			}).option('requirements', {
+				alias: 'r',
+				describe: 'Install requirements of the app',
+				type: 'boolean',
 			});
 		},
 		async (argv) => {
-			utils.installAppFrom(argv.path);
+			if(argv.requirements) utils.installReq(argv.path);
+			else utils.installAppFrom(argv.path);
 		},
 	)
 	.command(
@@ -261,14 +247,20 @@ yargs(hideBin(process.argv))
 			const pkg = JSON.parse(readFileSync(path.resolve(__dirname, '../../../package.json'), { encoding: 'utf-8' }));
 			const getLatest = async () => {
 				try{
-					return (await (await fetch(`https://registry.npmjs.org/${pkg.name}`)).json()).dist_tags.latest.yellow.bold
+					return (await req(`https://registry.npmjs.org/${pkg.name}`)).data['dist-tags'].latest
 				} catch(e) {
 					return `(${'!err'.blue.bgRed}, see ${`https://npmjs.com/package/${pkg.name}`.blue.underline})`;
 				}
 			}
 			log(`${'Rew'.red.bold} ${'RUNTIME'.yellow}`);
-			log(`Version: ${pkg.name.green}@${pkg.version.yellow.bold}`);
-			log(`Latest: ${pkg.name}@${await getLatest()}`, ':end');
+			log(`Version: ${pkg.name.green.bold}@${pkg.version.yellow.bold}`.magenta.bold);
+			const latest = await getLatest();
+			const isLatest = latest === pkg.version;
+			log(`Latest: ${pkg.name.cyan.bold}@${latest.yellow.bold}`.green.bold, isLatest ? ':end' : '');
+			if(!isLatest){
+				log(`There is an update available`.cyan.bold);
+				log('Update With:'.yellow, `npm i -g ${npm_package_name}`.green.bold, ':end');
+			}
 		},
 	)
 	.command(

package/lib/rew/cli/run.js

@@ -1,15 +1,8 @@
+// run.js
 const { run } = require('../main');
 
-function exec(filePath) {
-	return run(filePath).context.module.imports;
+function exec(filePath, argv) {
+	return run(filePath, { argv })?.context?.module?.imports || [];
 }
 
-const onmsg = ({ filePath, watch }) => {
-	const imports = exec(filePath);
-	if (watch) {
-		process.send(imports);
-	}
-	process.off('message', onmsg);
-};
-
-process.on('message', onmsg);
+module.exports = { execRewFile: exec };

package/lib/rew/cli/utils.js

@@ -4,7 +4,7 @@ const conf = require('../pkgs/conf');
 const jsYaml = require('js-yaml');
 const readline = require('readline');
 const { log, logget } = require('./log');
-const { execSync, exec } = require('child_process');
+const { fork, execSync, exec } = require('child_process');
 const { run } = require('../main');
 const { generateRandomID } = require('../functions/id');
 const { compile } = require('../modules/compiler');
@@ -12,10 +12,46 @@ const { to_qrew } = require('../qrew/compile');
 const { findAppInfo } = require('../misc/findAppInfo');
 const { req } = require('../misc/req');
 const { CONFIG_PATH } = require('../const/config_path');
+const { watch } = require('chokidar');
+const { execRewFile } = require('./run');
 
-const npm_package_name = '@makano/rew';
+const binpath = path.join(conf({}).create('').root, '.bin');
+const localBinPath = path.join(binpath, '../../../', 'bin');
 
 module.exports = {
+	runFile(filePath, options = {}, argv) {
+		const watching = [];
+		const watchIt = (file) => {
+			if (watching.includes(file)) return;
+			watch(file).on('change', () => runIt());
+			watching.push(file);
+		};
+
+		const runIt = () => {
+			if (options.watch) console.clear();
+			const imports = execRewFile(filePath, [filePath, ...(argv || [])]);
+			if (options.watch) {
+				imports.forEach((file) => {
+					watchIt(file);
+				});
+				watchIt(filePath);
+			}
+		};
+
+		runIt();
+	},
+	runFileWithArgv(filePath, options = {}, cargv) {
+		const argv = cargv || process.argv;
+		argv.shift();
+		if (argv[0].endsWith('rew')) {
+			if (argv[1] == 'run') {
+				argv.splice(0, 3);
+			} else if(argv[1] == '-w' || argv[1] == '--watch'){
+				argv.splice(0, 3);
+			} else argv.splice(0, 2);
+		}
+		this.runFile(filePath, options, argv)
+	},
 	conf(command, fullPath, key, value) {
 		const con = conf({});
 		if (command == 'get') {
@@ -69,8 +105,9 @@ module.exports = {
 			fs.mkdirSync(projectPath, { recursive: true });
 			const confPath = path.join(projectPath, 'app.yaml');
 			const entryFile = path.join(projectPath, 'main.coffee');
-			fs.writeFileSync(confPath, jsYaml.dump({ package: project.package, entry: 'main.coffee' }));
+			fs.writeFileSync(confPath, jsYaml.dump({ manifest: { package: project.package, private: false }, exec: { entry: 'main.coffee' }, assets: { icon: 'assets/icon.png', folder: './assets' }, install: { requirements: [] } }));
 			fs.writeFileSync(entryFile, `print("Hello World!")`);
+			fs.mkdirSync(path.join(projectPath, 'assets'), { recursive: true });
 			if (project.git) {
 				fs.writeFileSync(path.join(projectPath, '.gitignore'), `node_modules/\npackage-lock.json`);
 				execSync('cd ' + projectPath + ' && git init . && git branch -m main', { stdio: 'ignore' });
@@ -111,22 +148,20 @@ module.exports = {
 
 		const runAppRoot = (root, confPath, byPath) => {
 			const c = jsYaml.load(fs.readFileSync(confPath, { encoding: 'utf-8' }));
-			if (c.entry) {
-				if(byPath && options.dev) c.entry = c.entry.endsWith('.qrew') ? c.entry.replace(/\.qrew$/, '.coffee') : c.entry;
-				let r = path.resolve(root, c.entry);
-				if(options.build) {
+			if (options.entry) {
+				c.exec.entry = c.exec[options.entry] || c.exec.entry;
+			}
+			if (c.exec.entry) {
+				if (byPath && options.dev) c.exec.entry = c.entry.endsWith('.qrew') ? c.exec.entry.replace(/\.qrew$/, '.coffee') : c.exec.entry;
+				let r = path.resolve(root, c.exec.entry);
+				if (options.build) {
 					this.build({
 						file: r,
 						translate: options.translate || false
 					});
-					r = path.resolve(root, c.entry.replace(new RegExp(path.extname(c.entry).replace('.', '\\.') + '$'), options.translate ? '.js' : '.qrew'));
+					r = path.resolve(root, c.exec.entry.replace(new RegExp(path.extname(c.exec.entry).replace('.', '\\.') + '$'), options.translate ? '.js' : '.qrew'));
 				}
-				const mod_path = path.resolve(root, 'snode_moduless/@makano/rew');
-				const mod_path_lib = path.join(mod_path, 'lib/rew/cli');
-				if (fs.existsSync(mod_path) && __dirname !== mod_path_lib) {
-					const mod_path_utilsjs = path.join(mod_path_lib, '../main.js');
-					require(mod_path_utilsjs).run(r);
-				} else run(r);
+				this.runFileWithArgv(r);
 			}
 		};
 
@@ -151,7 +186,7 @@ module.exports = {
 		if (fs.existsSync(apppath) && fs.existsSync(appConfpath)) {
 			const c = jsYaml.load(fs.readFileSync(appConfpath, { encoding: 'utf-8' }));
 			const p = JSON.parse(fs.readFileSync(appPackagepath, { encoding: 'utf-8' }));
-			const pname = c.package;
+			const pname = c.manifest.package;
 			const installPath = path.join(conf({}).create(pname).root, 'app');
 			const rl = readline.createInterface({
 				input: process.stdin,
@@ -159,7 +194,7 @@ module.exports = {
 			});
 			log(' Installing '.blue + pname.green.bold);
 			log(' Package'.blue + ': ' + p.name.green + '@' + p.version.yellow);
-			if (p.description) {
+			if (p.descriptiondescription) {
 				log(' Description'.blue + ': ' + p.description);
 			}
 			rl.question(logget('Install '.blue + pname.green.bold + '? (y/N) '), (f) => {
@@ -173,21 +208,38 @@ module.exports = {
 						execSync(`rm -r ${apppath}`);
 					}
 					log(' Installed '.green + pname.cyan.bold, c.install ? '' : ':end');
-					if(c.install){
-						if(c.install.build){
+					if (c.install) {
+						if (c.install.build) {
 							log(' Building'.blue);
 							this.build({
 								...c.install.build,
 								file: path.join(installPath, c.install.build.file)
 							});
 						}
-						if(c.install.commands){
-							for(let command of c.install.commands){
+						if (c.install.commands) {
+							for (let command of c.install.commands) {
 								execSync(command.replace(/\$installPath/g, installPath));
 							}
 						}
-						if(c.install.file){
-							run(path.join(installPath, c.install.file));
+						if (c.install.file) {
+							this.runFileWithArgv(path.join(installPath, c.exec[c.install.file] || c.install.file), {}, []);
+						}
+						if (c.install.requirements) {
+							this.installReq(c);
+						}
+						if (c.install.exec) {
+							// this.installReq(c);
+							for (let i in c.install.exec) {
+								let iff = c.install.exec[i];
+								if (iff in c.exec) iff = c.exec[iff];
+								const file = path.join(installPath, iff);
+								const filepath = path.join(binpath, i);
+								const binfp = path.join(localBinPath, i);
+								if (!fs.existsSync(localBinPath)) fs.mkdirSync(localBinPath, { recursive: true });
+								fs.writeFileSync(filepath, `#!/usr/bin/env bash\n#@app.${pname}\nrew ${file} $*`);
+								fs.chmodSync(filepath, '755');
+								fs.linkSync(filepath, binfp);
+							}
 						}
 					}
 					rl.close();
@@ -203,7 +255,21 @@ module.exports = {
 			log(' Path is not a rew app'.red.bold, ':end');
 		}
 	},
-	build(argv){
+	installReq(config) {
+		if (typeof config !== "object") {
+			const confPath = path.join(config, './app.yaml');
+			if (!fs.existsSync(confPath)) return log(' Path is not a rew app'.red.bold, ':end');
+			config = jsYaml.load(fs.readFileSync(confPath, { encoding: 'utf-8' }));
+		}
+		if (config.install?.requirements) {
+			if (!Array.isArray(config.install.requirements)) return log(' Requirements must be an array'.red.bold, ':end');
+			config.install.requirements.forEach(req => {
+				log('Finding '.cyan + req.green);
+				this.installAppFrom(req);
+			});
+		}
+	},
+	build(argv) {
 		function readFile(filePath) {
 			return fs.readFileSync(filePath, { encoding: 'utf-8' });
 		}
@@ -236,7 +302,7 @@ module.exports = {
 			const newFilePath = path.join(dirName, `${baseName}.${argv.translate ? 'js' : 'qrew'}`);
 			fs.writeFileSync(newFilePath, compiledCode);
 			log(`${'Compiled'.green.bold}: ${newFilePath.yellow}`);
-			if(argv.remove){
+			if (argv.remove) {
 				fs.unlinkSync(filePath);
 				log(`${'Removed'.red.bold}: ${filePath.yellow}`);
 			}
@@ -264,7 +330,7 @@ module.exports = {
 
 			const appPath = findAppInfo(filePath);
 
-			const compiled = argv.translate ? compile({ content }, {}) : to_qrew(content, appPath?.config?.package || path.basename(filePath).split('.').slice(0, -1).join('.'));
+			const compiled = argv.translate ? compile({ content }, {}) : to_qrew(content, appPath?.config?.manifest?.package || path.basename(filePath).split('.').slice(0, -1).join('.'));
 			writeCompiledFile(filePath, compiled);
 		}
 
@@ -279,7 +345,7 @@ module.exports = {
 		const p = gitpath.split('github:')[1];
 		const url = `https://github.com/${p}`;
 		const apiurl = `https://api.github.com/repos/${p}`;
-		try{
+		try {
 			const response = await req(apiurl);
 			if (response.status !== 200) return log(' Repo not found'.red.bold, ':end');
 			log(''.blue, 'Cloning from github'.yellow);
@@ -288,39 +354,49 @@ module.exports = {
 			log(''.blue, 'Installing deps...'.yellow);
 			execSync(`cd ${tempPath} && npm i`);
 			return tempPath;
-		} catch(e){
+		} catch (e) {
 			log(' Repo not found'.red.bold, ':end');
 		}
 	},
-	findRepo(repo){
+	findRepo(repo) {
 		const repos = conf({}).create('').optionCenter('repos');
 		return repos.get(repo);
 	},
-	async installAppFrom(path){
+	async installAppFrom(path) {
 		if (path.startsWith('github:')) this.installApp(await this.cloneGit(path), true, true);
-		else if(path.startsWith('@')) this.fromRepo(path);
+		else if (path.startsWith('@')) this.fromRepo(path);
 		else this.installApp(path);
 	},
-	uninstall(packageName, all){
+	uninstall(packageName, all) {
 		const confPath = path.join(CONFIG_PATH, packageName);
 		const apppath = path.resolve(confPath, 'app');
 		const appConfpath = path.join(apppath, 'app.yaml');
-		if(!fs.existsSync(appConfpath) && fs.existsSync(confPath) && !all){
+		if (!fs.existsSync(appConfpath) && fs.existsSync(confPath) && !all) {
 			log(` App ${packageName.green}`.red.bold, `not found`.red.bold, `but configs are found.`.green.bold);
 			return log(`Use the`.cyan, '--all'.green, 'flag to remove them.'.cyan, ':end');
-		} else if(!fs.existsSync(appConfpath) && !all){
+		} else if (!fs.existsSync(appConfpath) && !all) {
 			return log(` App ${packageName.green}`.red.bold, `not found.`.red.bold, ':end');
 		}
 		log('Uninstalling'.cyan, packageName.green);
-		execSync('rm -rf '+(all ? confPath : apppath));
+		execSync('rm -rf ' + (all ? confPath : apppath));
+		fs.readdirSync(binpath)
+			.forEach(filename => {
+				const filepath = path.join(binpath, filename);
+				const lfilepath = path.join(localBinPath, filename);
+				const content = fs.readFileSync(filepath, { encoding: 'utf-8' });
+				if (content.split('\n')[1].startsWith('#@app.' + packageName)) {
+					fs.unlinkSync(lfilepath);
+					fs.unlinkSync(filepath);
+				}
+			});
 		log('Uninstalled'.cyan, ':end');
 	},
-	async getRepoJson(repoUrl){
-		try{
-			const text = (await req(repoUrl.startsWith('//.') ? 'http://'+repoUrl.slice(3) : repoUrl.startsWith('//') ? 'https://'+repoUrl : repoUrl)).data;
+	async getRepoJson(repoUrl) {
+		try {
+			const text = (await req(repoUrl.startsWith('//.') ? 'http://' + repoUrl.slice(3) : repoUrl.startsWith('//') ? 'https://' + repoUrl : repoUrl)).data;
 			const json = text.startsWith('---') || text.startsWith('%YAML') ? jsYaml.loadAll(text)[0] : JSON.parse(text);
-			if(Array.isArray(json.include)){
-				for(let i of json.include){
+			if (Array.isArray(json.include)) {
+				for (let i of json.include) {
 					json.packages = {
 						...json.packages,
 						...((await this.getRepoJson(i.startsWith('.') ? path.join(path.dirname(repoUrl), i) : i)).packages || {})
@@ -328,29 +404,29 @@ module.exports = {
 				}
 			}
 			return json;
-		} catch(e){
+		} catch (e) {
 			log(` Fetch Error. Check your connection.`.red.bold);
 			return {};
 		}
 	},
-  async fromRepo(repoAndPkg){
-    const [repo, pkg] = repoAndPkg.slice(1).split('/');
+	async fromRepo(repoAndPkg) {
+		const [repo, pkg] = repoAndPkg.slice(1).split('/');
 		const repoUrl = this.findRepo(repo);
-		if(!repoUrl){
-		 	log(` Repository "${repo.green}"`.red.bold, `not found.`.red.bold);
+		if (!repoUrl) {
+			log(` Repository "${repo.green}"`.red.bold, `not found.`.red.bold);
 			return log(`Add with:`.yellow, '\n\t$'.green, `rew repo add ${repo} URL`.cyan.bold, ':end');
 		} else {
 			const repoJson = await this.getRepoJson(repoUrl);
-			if(repoJson?.packages?.[pkg]){
+			if (repoJson?.packages?.[pkg]) {
 				await this.installAppFrom(repoJson.packages[pkg]);
 			} else {
-				log(` Package "${pkg}" is not in repo "${repo.green}"`.red.bold, ":end");
+				log(` Package "${pkg.cyan}" is not in repo "${repo.green}"`.red.bold, ":end");
 			}
 		}
-  },
+	},
 	async repo(command, key, value) {
 		const confInstance = conf({}).create('').optionCenter('repos') || {};
-	
+
 		if (command === 'add' || command === 'set') {
 			confInstance.set(key, value.replace('https://', '//').replace('http://', '//.'));
 		} else if (command === 'get') {
@@ -362,11 +438,11 @@ module.exports = {
 		} else if (command === 'view') {
 			if (key) {
 				const url = confInstance.get(key);
-				if(!url) return log(' Repo not found'.red.bold, ':end');
+				if (!url) return log(' Repo not found'.red.bold, ':end');
 				const json = await this.getRepoJson(url);
-				if(json.name) log(json.name);
+				if (json.name) log(json.name);
 				log('Packages:'.yellow)
-				if(json.packages) Object.keys(json.packages).forEach(name => log(name)) || log(`${Object.keys(json.packages).length} Packages in ${key}`, ':end');
+				if (json.packages) Object.keys(json.packages).forEach(name => log(name)) || log(`${Object.keys(json.packages).length} Packages in ${key}`, ':end');
 				else log('None'.blue, ':end')
 			} else {
 				console.log(Object.keys(confInstance.getAll()).join('\n'));
@@ -376,8 +452,10 @@ module.exports = {
 		} else {
 			log(' Invalid command'.red.bold, ':end');
 		}
-	},	
-	initFirst(){
+	},
+	initFirst() {
+		log('First time init')
 		conf({}).create('').optionCenter('repos').set('rewpkgs', '//raw.githubusercontent.com/kevinJ045/rewpkgs/main/main.yaml');
+		fs.mkdirSync(binpath, { recursive: true });
 	}
 };

package/lib/rew/const/default.js

@@ -7,8 +7,10 @@ const { match } = require('../functions/match');
 const { map } = require('../functions/map');
 const { typex, typeis, typedef, typei, int, float, num, str, bool } = require('../functions/types');
 const { isEmpty, clone, deepClone, merge, uniqueId, compose, curry } = require('../functions/core');
-const { print, input } = require('../functions/stdout');
+const { print, input, clear } = require('../functions/stdout');
 const { curl } = require('../functions/curl');
+const { wait } = require('../functions/wait');
+const { scheduleFrame } = require('../functions/misc');
 
 module.exports = {
 	cenum,
@@ -16,8 +18,11 @@ module.exports = {
 	future,
 	emitter,
 	sleep,
+	wait,
+	scheduleFrame,
 	match,
 	map,
+	clear,
 
 	typex,
 	typei,

package/lib/rew/const/files.js

@@ -1,15 +1,9 @@
 const fs = require('fs');
 const path = require('path');
-
-const HOME_PATH = path.resolve(process.env.HOME, '.config/rew/default');
-const THEME_PATH = (module.exports.THEME_PATH = path.resolve(HOME_PATH, 'theme.css'));
+const { CONFIG_PATH } = require('./config_path');
 
 module.exports.FILES = [
 	{
-		path: HOME_PATH,
-	},
-	{
-		path: THEME_PATH,
-		content: fs.readFileSync(path.resolve(__dirname, '../css/theme.css')),
-	},
+		path: CONFIG_PATH,
+	}
 ];

package/lib/rew/const/pre-exec.js

@@ -0,0 +1,3 @@
+Function.prototype.wait = function(...args) {
+	return wait(this, ...args);
+};

package/lib/rew/functions/import.js

@@ -14,14 +14,15 @@ const lookUpInOtherApps = (fullPath) => {
 	const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
 	let dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
 	let ppath = path.join(con.CONFIG_PATH, name, 'app');
-	const config = jsYaml.load(readFileSync(path.join(ppath, 'app.yaml'), 'utf-8'));
 	if (!existsSync(ppath)) return null;
+	const config = jsYaml.load(readFileSync(path.join(ppath, 'app.yaml'), 'utf-8'));
 	if (!dpath) {
-		dpath = config.entry;
+		dpath = config.exec.entry;
 	}
 	if(config.private == true) return null;
+	if(dpath in config.exec) dpath = config.exec[dpath];
 	const pepath = path.join(ppath, dpath);
-	if(Array.isArray(config.private)){
+	if(Array.isArray(config.manifest.private)){
 		if(config.private.find(f => pepath == path.join(ppath, f))) return null;
 	}
 	if (existsSync(pepath)) return pepath;

package/lib/rew/functions/misc.js

@@ -0,0 +1,5 @@
+
+module.exports.scheduleFrame = function scheduleFrame(cb, immediate = false){
+	return immediate ? setImmediate(cb) : setTimeout(cb, 1);
+}
+

package/lib/rew/functions/require.js

@@ -35,6 +35,4 @@ function resolveModulePath(modulePath, filePath) {
 			}
 		}
 	}
-
-	throw new Error(`Cannot find module '${modulePath}'`);
 }

package/lib/rew/functions/sleep.js

@@ -1,5 +1,5 @@
 const future = require('./future');
 
 module.exports = async function sleep(time) {
-	return new Promise((r) => setTimeout(r, time));
+	return new Promise((r) => setTimeout(() => r(time), time));
 };