total5 0.0.1 → 0.0.2

package/edit.js

@@ -0,0 +1,462 @@
+// Total.js Edit
+// The MIT License
+// Copyright 2020-2024 (c) Peter Širka <petersirka@gmail.com>
+
+'use strict';
+
+const SKIP = /\/\.git\//;
+const VERSION = 1;
+const HEADER = '> Total.js Code Editor';
+const DIVIDER = '----------------------------------------------------';
+
+exports.init = function(url) {
+
+	var client = F.websocketclient();
+
+	client.options.reconnect = 10000;
+	client.options.reconnectserver = true;
+
+	client.on('message', function(msg) {
+
+		if (msg.TYPE === 'init') {
+			console.log(DIVIDER);
+			console.log(HEADER + ': Welcome to "' + msg.name + ' (' + msg.version + ')"');
+			console.log('> Project: "' + msg.project + '"');
+			console.log(DIVIDER);
+			return;
+		}
+
+		F.action('editor', msg).callback(function(err, response) {
+
+			if (err) {
+				msg.error = err;
+			} else {
+				msg.response = response;
+				msg.success = true;
+			}
+
+			client.send(msg);
+		});
+	});
+
+	client.on('open', function() {
+		client.send({ TYPE: 'init', version: VERSION });
+	});
+
+	client.on('close', function(e) {
+
+		if (e === 4004) {
+			console.log(HEADER + ': 404 project not found');
+			// Tries again in 10 second interval
+			// client.destroy();
+			return;
+		}
+
+		if (e === 4009) {
+			console.log(HEADER + ': 409 project is already open');
+			client.destroy();
+			return;
+		}
+
+	});
+
+	client.on('error', function(err) {
+		console.log(HEADER + ':', err.message);
+	});
+
+	client.connect(url.replace(/^http/, 'ws'));
+
+};
+
+F.newaction('editor', {
+	name: 'Code editor',
+	input: '*TYPE,path,data,nocompress:Boolean',
+	action: function($, model) {
+
+		switch (model.TYPE) {
+
+			case 'ping':
+				$.success(VERSION);
+				break;
+
+			// Browse files
+			case 'browse':
+				browse($, model);
+				break;
+
+			// Download
+			case 'download':
+				download($, model);
+				break;
+
+			// import
+			case 'import':
+				customimport($, model);
+				break;
+
+			// upload
+			case 'send':
+				send($, model);
+				break;
+
+			// Creates file/directory
+			case 'create':
+				create($, model);
+				break;
+
+			// Loads file
+			case 'load':
+				load($, model);
+				break;
+
+			// Saves file
+			case 'save':
+				save($, model);
+				break;
+
+			// Removes file
+			case 'remove':
+				remove($, model);
+				break;
+
+			// Modifies file
+			case 'modify':
+				modify($, model);
+				break;
+
+			// Reads info about the file
+			case 'info':
+				info($, model);
+				break;
+
+			// Reads log file
+			case 'log':
+				log($, model);
+				break;
+
+			case 'rename':
+				rename($, model);
+				break;
+
+			case 'upload':
+				upload($, model);
+				break;
+
+			// Clears log
+			case 'logclear':
+				clearlog($, model);
+				break;
+
+			case 'wiki':
+				wiki($, model);
+				break;
+
+			case 'ip':
+				ipaddress($, model);
+				break;
+
+			default:
+				$.invalid(400);
+				break;
+		}
+	}
+});
+
+function mkdir(path, callback) {
+	F.Fs.mkdir(path, { recursive: true }, callback);
+}
+
+function browse($, model) {
+	var path = F.path.root();
+	var m = (model.data || '{}').parseJSON() || EMPTYARRAY;
+	var skip = m.skip ? new RegExp(m.skip) : null;
+	var validator;
+
+	if (m.type === 'localization')
+		validator = ((path, dir) => dir ? (path.endsWith('/databases') || path.endsWith('/node_modules') || path.endsWith('/tmp') || path.endsWith('/.git') || path.endsWith('/.src') || path.endsWith('/logs')) ? false : true : true);
+	else
+		validator = n => !SKIP.test(n) && (!skip || !skip.test(n));
+
+	F.TUtils.ls(path, function(files, directories) {
+
+		for (var i = 0; i < files.length; i++)
+			files[i] = files[i].substring(path.length);
+
+		for (var i = 0; i < directories.length; i++)
+			directories[i] = directories[i].substring(path.length);
+
+		if (m.type === 'localization') {
+			var allowed = { html: 1, js: 1 };
+			files = files.remove(n => allowed[F.TUtils.getExtension(n)] != 1);
+		}
+
+		$.callback({ files: files, directories: directories });
+
+	}, validator, true);
+}
+
+function log($, model) {
+	var filename = F.Path.normalize(F.path.root(model.path));
+	F.Fs.stat(filename, function(err, stats) {
+		if (stats) {
+			var start = stats.size - (1024 * 4); // Max. 4 kB
+			if (start < 0)
+				start = 0;
+			var buffer = [];
+			F.Fs.createReadStream(filename, { start: start < 0 ? 0 : start }).on('data', chunk => buffer.push(chunk)).on('end', function() {
+				$.callback(Buffer.concat(buffer).toString('utf8'));
+			});
+		} else {
+			$.callback('');
+		}
+	});
+}
+
+function clearlog($, model) {
+	var filename = F.path.root(model.path);
+	F.Fs.truncate(filename, NOOP);
+	$.success();
+}
+
+function load($, model) {
+	var filename = F.Path.normalize(F.path.root(model.path));
+	F.Fs.readFile(filename, function(err, data) {
+
+		if (err) {
+			$.invalid(err);
+			return;
+		}
+
+		var index = -1;
+
+		while (true) {
+			index += 1;
+			if (data.length <= index || data[index] !== 0)
+				break;
+		}
+
+		if (index !== -1)
+			data = data.slice(index);
+
+		encodedata(model, data, function(err, buffer) {
+			if (err)
+				$.invalid(err);
+			else
+				$.callback({ type: F.TUtils.contentTypes[F.TUtils.getExtension(model.path)], data: buffer.toString('base64') });
+		});
+	});
+}
+
+function save($, model) {
+
+	// Tries to create a folder
+	var filename = F.path.root(model.path);
+	var name = F.TUtils.getName(model.path);
+	var directory = F.Path.normalize(filename.substring(0, filename.length - name.length));
+
+	mkdir(directory, function() {
+		decodedata(model, function(err, buffer) {
+			if (err)
+				$.invalid(err);
+			else
+				F.Fs.writeFile(F.Path.normalize(filename), buffer, $.done());
+		});
+	});
+}
+
+function remove($, model) {
+	var filename = F.Path.normalize(F.path.root(model.path));
+	try {
+		var stats = F.Fs.lstatSync(filename);
+		if (stats.isFile()) {
+			F.Fs.unlink(filename, NOOP);
+		} else {
+			if (stats.isDirectory())
+				F.path.rmdir(filename);
+			else
+				F.Fs.unlink(filename, NOOP);
+		}
+	} catch (e) {}
+
+	$.success();
+}
+
+function info($, model) {
+	var filename = F.Path.normalize(F.path.root(model.path));
+	F.Fs.lstat(filename, $.callback);
+}
+
+function download($, model) {
+	var filename = F.Path.normalize(F.path.root(model.path));
+	var ext = F.TUtils.getExtension(model.path);
+	F.Fs.lstat(filename, function(err, stats) {
+		if (err || stats.isDirectory() || stats.isSocket()) {
+			$.status = 400;
+			$.invalid('400', 'error-file');
+		} else {
+			// Max. 5 MB
+			if (stats.size > (1024 * 1024 * 5)) {
+				$.invalid('Too large');
+			} else {
+				F.Fs.readFile(filename, function(err, data) {
+					if (err) {
+						$.invalid(err);
+					} else {
+						encodedata(model, data, function(err, buffer) {
+							if (err)
+								$.invalid(err);
+							else
+								$.callback({ type: F.TUtils.contentTypes[ext], data: buffer.toString('base64') });
+						});
+					}
+				});
+			}
+		}
+	});
+}
+
+function send($, model) {
+	var filename = F.Path.normalize(F.path.root(model.path));
+	F.Fs.fstat(filename, function() {
+		var opt = {};
+		opt.method = 'GET';
+		opt.url = model.data;
+		opt.files = [{ name: F.TUtils.getName(filename), filename: filename }];
+		opt.callback = $.done();
+		REQUEST(opt);
+	});
+}
+
+function customimport($, model) {
+	var filename = F.Path.normalize(F.path.root(model.path));
+	DOWNLOAD(model.data, filename, $.done());
+}
+
+const SchemaRename = F.TUtils.jsonschema('newpath:String,oldpath:String');
+
+function rename($, model) {
+
+	var data = SchemaRename.transform((model.data || '{}').parseJSON());
+	if (data.error) {
+		$.invalid(data.error);
+		return;
+	}
+
+	data = data.response;
+
+	data.newpath = F.Path.normalize(F.path.root(data.newpath));
+	data.oldpath = F.Path.normalize(F.path.root(data.oldpath));
+
+	mkdir(F.Path.dirname(data.newpath), function() {
+		F.Fs.rename(data.oldpath, data.newpath, $.done());
+	});
+}
+
+function create($, model) {
+
+	// model.path {String}
+	// model.data {Object}
+	// model.data.clone {String}
+	// model.data.folder {Boolean}
+
+	var filename = F.Path.normalize(F.path.root(model.path));
+	var data = (model.data || '{}').parseJSON();
+
+	F.Fs.lstat(filename, function(err) {
+
+		if (err) {
+			// file not found
+			// we can continue
+			if (data.folder) {
+				if (model.clone)
+					F.Fs.cp(F.Path.normalize(F.path.root(data.clone)), filename, { recursive: true, force: true }, $.done());
+				else
+					mkdir(filename, $.done());
+			} else {
+				var name = F.TUtils.getName(filename);
+				mkdir(filename.substring(0, filename.length - name.length), function() {
+					if (data.clone)
+						F.Fs.copyFile(F.Path.normalize(F.path.root(data.clone)), filename, $.done());
+					else
+						F.Fs.writeFile(filename, '', $.done());
+				});
+			}
+		} else
+			$.invalid('path', model.path + ' already exists');
+	});
+}
+
+function upload($, model) {
+	var name = F.TUtils.getName(model.path);
+	var filename = F.Path.normalize(F.path.root(model.path));
+	var directory = F.Path.normalize(F.path.root(model.path.substring(0, model.length - name.length)));
+	mkdir(directory, function() {
+		decodedata(model, function(err, buffer) {
+			if (err)
+				$.invalid(err);
+			else
+				F.Fs.writeFile(filename, buffer, $.done());
+		});
+	});
+}
+
+function modify($, model) {
+	var filename = F.path.root(model.path);
+	var dt = new Date();
+	F.Fs.utimes(filename, dt, dt, NOOP);
+	$.success();
+}
+
+function wiki($) {
+
+	var path = F.Path.normalize(PATH.root());
+
+	F.TUtils.ls(path, function(files) {
+
+		var builder = [];
+
+		files.wait(function(item, next) {
+
+			if (item.substring(item.length - 3) === '.js') {
+				F.Fs.readFile(item, function(err, buffer) {
+					if (buffer) {
+						builder.push(buffer.toString('utf8'));
+						builder.push('');
+					}
+					next();
+				});
+			} else
+				next();
+
+		}, function() {
+			$.callback(builder.join('\n'));
+			$.cancel();
+		});
+
+	}, path => (/schemas|controllers/).test(path));
+
+}
+
+function ipaddress($) {
+	var opt = {};
+	opt.url = 'https://ipecho.net/plain';
+	opt.callback = function(err, response) {
+		$.callback(response.body || 'undefined');
+		$.cancel();
+	};
+	REQUEST(opt);
+}
+
+function decodedata(model, callback) {
+	if (model.nocompress)
+		callback(null, Buffer.from(model.data, 'base64'));
+	else
+		F.Zlib.inflate(Buffer.from(model.data, 'base64'), callback);
+}
+
+function encodedata(model, buffer, callback) {
+	if (model.nocompress)
+		callback(null, buffer);
+	else
+		F.Zlib.deflate(buffer, callback);
+}

package/error.html

@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<title>@{model.status}</title>
+	<meta charset="utf-8" />
+	<meta name="format-detection" content="telephone=no" />
+	<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no" />
+	<meta name="robots" content="all,follow" />
+	<style type="text/css">
+
+		/*auto*/
+		html,body { height: 100%; width: 100%; overflow: hidden; font-family: Arial; font-smoothing:antialiased; background-color: white; margin: 0; padding: 0; color: black; }
+		.table { display: table; width: 100%; height: 100%; table-layout: fixed; }
+		.body { padding: 20px; }
+		.cell { display: table-cell; vertical-align: middle; text-align: center; width: 100%; height: 100%; font-size: 30px; }
+		.cell b { font-size: 60px; background-color: #000; border-bottom: 5px solid #D0D0D0; color: #FFF; position: relative; display: inline-block; padding: 10px 15px; border-radius: 10px; margin-bottom: 20px; animation: anim 0.5s forwards 2s; }
+		.error { font-size: 11px; color: gray; width: 90%; max-width: 800px; margin: 20px auto; background-color: #F0F0F0; padding: 10px; border-radius: 2px; text-align: left; font-family: monospace; overflow: auto; }
+		#url { font-size: 12px; color: gray; margin: 5px 0; }
+
+		@keyframes anim {
+			0% { transform: rotate(0deg); }
+			50% { transform: rotate(-3deg) scale(1.3); }
+			100% { transform: rotate(5deg) scale(1); }
+		}
+
+		@media(max-width: 768px) {
+			.cell b { margin-bottom: 10px; }
+			.cell { font-size: 25px; }
+		}
+	</style>
+</head>
+<body>
+	<div class="table">
+		<div class="cell">
+			<div class="body">
+				<b>@{model.code}</b>
+				<div class="status">@{model.status}</div>
+				<div id="url"></div>
+				@{if model.error}<div class="error">@{model.error.replace(/\n/g, '<br>')}</div>@{fi}
+			</div>
+		</div>
+	</div>
+
+	<script>
+		document.getElementById('url').innerHTML = location.href;
+	</script>
+
+</body>
+</html>