cloudcmd 17.1.6 → 17.2.0

package/server/route.spec.mjs

@@ -0,0 +1,458 @@
+import path, {dirname} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {Readable} from 'node:stream';
+import fs from 'node:fs';
+import tryToCatch from 'try-to-catch';
+import {test, stub} from 'supertape';
+import serveOnce from 'serve-once';
+import cloudcmd from './cloudcmd.mjs';
+import {_getReadDir} from './route.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixtureDir = path.join(__dirname, '..', 'test', 'fixture');
+const {createConfigManager} = cloudcmd;
+
+const defaultConfig = {
+    auth: false,
+    dropbox: false,
+};
+
+const {request} = serveOnce(cloudcmd, {
+    config: defaultConfig,
+});
+
+const {stringify} = JSON;
+const {assign} = Object;
+
+test('cloudcmd: route: buttons: no console', async (t) => {
+    const options = {
+        config: {
+            console: false,
+        },
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.match(body, 'icon-console none', 'should hide console');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: console', async (t) => {
+    const config = {
+        console: true,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.notOk(/icon-console none/.test(body), 'should not hide console');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: no config', async (t) => {
+    const config = {
+        configDialog: false,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.match(body, 'icon-config none', 'should hide config');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: no contact', async (t) => {
+    const config = {
+        contact: false,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.match(body, 'icon-contact none', 'should hide contact');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: one file panel: move', async (t) => {
+    const config = {
+        oneFilePanel: true,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.match(body, 'icon-move none', 'should hide move button');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: one file panel: copy', async (t) => {
+    const config = {
+        oneFilePanel: true,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.match(body, 'icon-copy none', 'should hide copy button');
+    t.end();
+});
+
+test('cloudcmd: route: keys panel: hide', async (t) => {
+    const config = {
+        keysPanel: false,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.match(body, 'keyspanel hidden', 'should hide keyspanel');
+    t.end();
+});
+
+test('cloudcmd: route: keys panel', async (t) => {
+    const config = {
+        keysPanel: true,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.notOk(/keyspanel hidden/.test(body), 'should show keyspanel');
+    t.end();
+});
+
+test('cloudcmd: route: symlink', async (t) => {
+    const emptyDir = path.join(fixtureDir, 'empty-dir');
+    const root = fixtureDir;
+    const symlink = path.join(root, 'symlink-dir');
+    
+    const config = {
+        root,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    fs.symlinkSync(emptyDir, symlink);
+    
+    const {body} = await request.get('/fs/symlink-dir', {
+        options,
+    });
+    
+    fs.unlinkSync(symlink);
+    
+    t.ok(body.length, 'should return html document');
+    t.end();
+});
+
+test('cloudcmd: route: not found', async (t) => {
+    const root = fixtureDir;
+    const config = {
+        root,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/fs/file-not-found', {
+        options,
+    });
+    
+    t.match(body, 'ENOENT: no such file or directory', 'should return error');
+    t.end();
+});
+
+test('cloudcmd: route: sendIndex: encode', async (t) => {
+    const name = '"><svg onload=alert(3);>';
+    const nameEncoded = '&quot;&gt;&lt;svg onload=alert(3);&gt;';
+    const path = '/';
+    
+    const files = [{
+        name,
+    }];
+    
+    const stream = Readable.from(stringify({
+        path,
+        files,
+    }));
+    
+    assign(stream, {
+        path,
+        files,
+        type: 'directory',
+    });
+    
+    const read = stub().resolves(stream);
+    
+    cloudcmd.depStore('win32', {
+        read,
+    });
+    
+    const {request} = serveOnce(cloudcmd, {
+        configManager: createConfigManager(),
+    });
+    
+    const {body} = await request.get('/');
+    
+    cloudcmd.depStore();
+    
+    t.match(body, nameEncoded, 'should encode name');
+    t.end();
+});
+
+test('cloudcmd: route: sendIndex: encode: not encoded', async (t) => {
+    const name = '"><svg onload=alert(3);>';
+    const path = '/';
+    const files = [{
+        name,
+    }];
+    
+    const stream = Readable.from(stringify({
+        path,
+        files,
+    }));
+    
+    assign(stream, {
+        path,
+        files,
+        type: 'directory',
+    });
+    
+    const read = stub().resolves(stream);
+    
+    cloudcmd.depStore('win32', {
+        read,
+    });
+    
+    const {request} = serveOnce(cloudcmd);
+    const {body} = await request.get('/');
+    
+    cloudcmd.depStore();
+    
+    t.notOk(body.includes(name), 'should not put not encoded name');
+    t.end();
+});
+
+test('cloudcmd: route: sendIndex: ddos: render', async (t) => {
+    const name = `$$$'&quot;`;
+    const path = '/';
+    const files = [{
+        name,
+    }];
+    
+    const stream = Readable.from(stringify({
+        path,
+        files,
+    }));
+    
+    assign(stream, {
+        path,
+        files,
+        type: 'directory',
+    });
+    
+    const read = stub().resolves(stream);
+    
+    cloudcmd.depStore('win32', {
+        read,
+    });
+    const {request} = serveOnce(cloudcmd, {
+        config: defaultConfig,
+    });
+    
+    const {status} = await request.get('/');
+    
+    cloudcmd.depStore();
+    
+    t.equal(status, 200, 'should not hang up');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: no terminal', async (t) => {
+    const config = {
+        terminal: false,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.match(body, 'icon-terminal none', 'should hide terminal');
+    t.end();
+});
+
+test('cloudcmd: route: no termianl: /fs', async (t) => {
+    const config = {
+        terminal: false,
+    };
+    
+    const options = {
+        config,
+        configManager: createConfigManager(),
+    };
+    
+    const {request} = serveOnce(cloudcmd);
+    
+    const {body} = await request.get('/fs', {
+        options,
+    });
+    
+    t.match(body, 'icon-terminal none', 'should hide terminal');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: terminal: can not load', async (t) => {
+    const config = {
+        terminal: true,
+        terminalPath: 'xxxxxxxxxxxx',
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.match(body, 'icon-terminal none', 'should not enable terminal');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: terminal', async (t) => {
+    const config = {
+        terminal: true,
+        terminalPath: 'console-io',
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.notOk(/icon-terminal none/.test(body), 'should not enable terminal');
+    t.end();
+});
+
+test('cloudcmd: route: buttons: contact', async (t) => {
+    const config = {
+        contact: true,
+    };
+    
+    const options = {
+        config,
+    };
+    
+    const {request} = serveOnce(cloudcmd);
+    
+    const {body} = await request.get('/', {
+        options,
+    });
+    
+    t.notOk(/icon-contact none/.test(body), 'should enable terminal');
+    t.end();
+});
+
+test('cloudcmd: route: dropbox', async (t) => {
+    const config = createConfigManager();
+    config('dropbox', true);
+    config('dropboxToken', '');
+    
+    const readdir = _getReadDir(config);
+    const [e] = await tryToCatch(readdir, '/root');
+    
+    t.match(e.message, 'API', 'should contain word token in message');
+    t.end();
+});
+
+test('cloudcmd: route: content length', async (t) => {
+    const options = {
+        root: fixtureDir,
+    };
+    
+    const {headers} = await request.get('/route.js', {
+        options,
+    });
+    
+    const result = headers.get('content-length');
+    
+    t.ok(result);
+    t.end();
+});
+
+test('cloudcmd: route: read: root', async (t) => {
+    const stream = Readable.from('hello');
+    
+    stream.contentLength = 5;
+    
+    const read = stub().returns(stream);
+    cloudcmd.depStore('win32', {
+        read,
+    });
+    
+    const configManager = createConfigManager();
+    const root = '/hello';
+    
+    configManager('root', root);
+    
+    const {request} = serveOnce(cloudcmd, {
+        configManager,
+    });
+    
+    await request.get('/fs/route.js');
+    cloudcmd.depStore();
+    
+    const expected = ['/hello/route.js', {
+        root,
+    }];
+    
+    t.calledWith(read, expected);
+    t.end();
+});

package/server/server.mjs

@@ -1,18 +1,18 @@
-import cloudcmd from './cloudcmd.js';
 import http from 'node:http';
 import {promisify} from 'node:util';
+import process from 'node:process';
 import currify from 'currify';
 import squad from 'squad';
 import tryToCatch from 'try-to-catch';
-import wraptile from 'wraptile';
-import compression from 'compression';
-import threadIt from 'thread-it';
-import exit from './exit.js';
 import opn from 'open';
 import express from 'express';
 import {Server} from 'socket.io';
 import tryRequire from 'tryrequire';
-import process from 'node:process';
+import wraptile from 'wraptile';
+import compression from 'compression';
+import threadIt from 'thread-it';
+import exit from './exit.js';
+import cloudcmd from './cloudcmd.mjs';
 
 const bind = (f, self) => f.bind(self);
 

package/server/terminal.js

@@ -8,11 +8,15 @@ const noop = (req, res, next) => {
 
 noop.listen = noop;
 
-module.exports = (config, arg) => {
+function _getModule(a) {
+    return require(a);
+}
+
+module.exports = (config, arg, {getModule = _getModule} = {}) => {
     if (!config('terminal'))
         return noop;
     
-    const [e, terminalModule] = tryCatch(require, config('terminalPath'));
+    const [e, terminalModule] = tryCatch(getModule, config('terminalPath'));
     
     if (!e && !arg)
         return terminalModule;

package/server/terminal.spec.mjs

@@ -0,0 +1,73 @@
+import {test, stub} from 'supertape';
+import terminal from './terminal.js';
+import {createConfigManager} from './cloudcmd.mjs';
+
+test('cloudcmd: terminal: disabled', (t) => {
+    const config = createConfigManager();
+    config('terminal', false);
+    
+    const fn = terminal(config);
+    
+    t.notOk(fn(), 'should return noop');
+    t.end();
+});
+
+test('cloudcmd: terminal: disabled: listen', (t) => {
+    const config = createConfigManager();
+    config('terminal', false);
+    
+    const fn = terminal(config).listen();
+    
+    t.notOk(fn, 'should return noop');
+    t.end();
+});
+
+test('cloudcmd: terminal: enabled', (t) => {
+    const term = stub();
+    const arg = 'hello';
+    const config = stub().returns(true);
+    const getModule = stub().returns(term);
+    
+    terminal(config, arg, {
+        getModule,
+    });
+    
+    t.calledWith(term, [arg], 'should call terminal');
+    t.end();
+});
+
+test('cloudcmd: terminal: enabled: no string', (t) => {
+    const {log: originalLog} = console;
+    const log = stub();
+    
+    console.log = log;
+    const config = createConfigManager();
+    
+    config('terminal', true);
+    config('terminalPath', 'hello');
+    terminal(config);
+    
+    console.log = originalLog;
+    
+    const msg = `cloudcmd --terminal: Cannot find module 'hello'`;
+    const [arg] = log.args[0];
+    
+    t.match(arg, RegExp(msg), 'should call with msg');
+    t.end();
+});
+
+test('cloudcmd: terminal: no arg', (t) => {
+    const gritty = {};
+    const getModule = stub().returns(gritty);
+    const config = createConfigManager();
+    
+    config('terminal', true);
+    config('terminalPath', 'gritty');
+    
+    const result = terminal(config, '', {
+        getModule,
+    });
+    
+    t.equal(result, gritty);
+    t.end();
+});

package/server/{user-menu.js → user-menu.mjs}

@@ -1,26 +1,25 @@
-'use strict';
+import {createRequire} from 'node:module';
+import {homedir} from 'node:os';
+import {readFile as _readFile} from 'node:fs/promises';
+import {join} from 'node:path';
+import montag from 'montag';
+import tryToCatch from 'try-to-catch';
+import currify from 'currify';
+import threadIt from 'thread-it';
+import {codeframe} from 'putout';
 
-const {homedir} = require('node:os');
-const {readFile} = require('node:fs/promises');
-
-const {join} = require('node:path');
-
-const montag = require('montag');
-const tryToCatch = require('try-to-catch');
-const currify = require('currify');
-const threadIt = require('thread-it');
-const {codeframe} = require('putout');
+const require = createRequire(import.meta.url);
 const putout = threadIt(require.resolve('putout'));
 
 threadIt.init();
 // warm up worker cache
 transpile('');
 
-const URL = '/api/v1/user-menu';
-const DEFAULT_MENU_PATH = join(__dirname, '../static/user-menu.js');
+const PREFIX = '/api/v1/user-menu';
+const DEFAULT_MENU_PATH = new URL('../static/user-menu.js', import.meta.url).pathname;
 
-module.exports = currify(async ({menuName}, req, res, next) => {
-    if (req.url.indexOf(URL))
+export default currify(async ({menuName, readFile = _readFile}, req, res, next) => {
+    if (!req.url.startsWith(PREFIX))
         return next();
     
     const {method} = req;
@@ -30,14 +29,15 @@ module.exports = currify(async ({menuName}, req, res, next) => {
             req,
             res,
             menuName,
+            readFile,
         });
     
     next();
 });
 
-async function onGET({req, res, menuName}) {
+async function onGET({req, res, menuName, readFile}) {
     const {dir} = req.query;
-    const url = req.url.replace(URL, '');
+    const url = req.url.replace(PREFIX, '');
     
     if (url === '/default')
         return sendDefaultMenu(res);

package/server/user-menu.spec.mjs

@@ -0,0 +1,74 @@
+import {dirname, join} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {test, stub} from 'supertape';
+import serveOnce from 'serve-once';
+import threadIt from 'thread-it';
+import userMenu from './user-menu.mjs';
+import {readFileSync} from 'node:fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const {request} = serveOnce(userMenu);
+const userMenuPath = join(__dirname, '..', '.cloudcmd.menu.js');
+const userMenuFile = readFileSync(userMenuPath, 'utf8');
+
+const fixtureDir = new URL('fixture-user-menu', import.meta.url).pathname;
+const fixtureMoveName = join(fixtureDir, 'io-mv.js');
+const fixtureMoveFixName = join(fixtureDir, 'io-mv-fix.js');
+const fixtureCopyName = join(fixtureDir, 'io-cp.js');
+const fixtureCopyFixName = join(fixtureDir, 'io-cp-fix.js');
+
+const fixtureMove = readFileSync(fixtureMoveName, 'utf8');
+const fixtureMoveFix = readFileSync(fixtureMoveFixName, 'utf8');
+const fixtureCopy = readFileSync(fixtureCopyName, 'utf8');
+const fixtureCopyFix = readFileSync(fixtureCopyFixName, 'utf8');
+
+test('cloudcmd: user menu', async (t) => {
+    const options = {
+        menuName: '.cloudcmd.menu.js',
+    };
+    
+    const {body} = await request.get(`/api/v1/user-menu?dir=${__dirname}`, {
+        options,
+    });
+    
+    t.equal(userMenuFile, body);
+    t.end();
+});
+
+test('cloudcmd: user menu: io.mv', async (t) => {
+    const readFile = stub().returns(fixtureMove);
+    const options = {
+        menuName: '.cloudcmd.menu.js',
+        readFile,
+    };
+    
+    const {request} = serveOnce(userMenu);
+    
+    const {body} = await request.get(`/api/v1/user-menu?dir=${__dirname}`, {
+        options,
+    });
+    
+    t.equal(body, fixtureMoveFix);
+    t.end();
+});
+
+test('cloudcmd: user menu: io.cp', async (t) => {
+    const readFile = stub().returns(fixtureCopy);
+    const options = {
+        menuName: '.cloudcmd.menu.js',
+        readFile,
+    };
+    
+    const {request} = serveOnce(userMenu);
+    
+    const {body} = await request.get(`/api/v1/user-menu?dir=${__dirname}`, {
+        options,
+    });
+    
+    threadIt.terminate();
+    
+    t.equal(body, fixtureCopyFix);
+    t.end();
+});