goblin-laboratory 4.6.5 → 4.7.1

package/lib/termux.js

@@ -0,0 +1,367 @@
+// @ts-check
+const {Elf} = require('xcraft-core-goblin');
+const {string, boolean, array, option, object} = require('xcraft-core-stones');
+const {parseOptions} = require('xcraft-core-utils/lib/reflect.js');
+
+class OrderedSet {
+  #set = new Set();
+  #list = [];
+
+  add(value) {
+    if (!this.#set.has(value)) {
+      this.#set.add(value);
+      this.#list.push(value);
+    }
+  }
+
+  delete(value) {
+    if (this.#set.delete(value)) {
+      this.#list = this.#list.filter((v) => v !== value);
+    }
+  }
+
+  last() {
+    return this.#list[this.#list.length - 1];
+  }
+
+  previous(value) {
+    const i = this.#list.indexOf(value);
+    return i > 0 ? this.#list[i - 1] : undefined;
+  }
+
+  next(value) {
+    const i = this.#list.indexOf(value);
+    return i < this.#list.length - 1 && i >= 0 ? this.#list[i + 1] : undefined;
+  }
+}
+
+class TermuxShape {
+  id = string;
+  prompt = string;
+  busy = boolean;
+  history = array(string);
+  completion = string;
+  value = string;
+
+  inputCommand = boolean;
+  cmd = option(string);
+  args = option(object);
+}
+
+class TermuxState extends Elf.Sculpt(TermuxShape) {}
+
+class TermuxLogic extends Elf.Spirit {
+  state = new TermuxState({
+    id: 'termux',
+    prompt: '~ $',
+    busy: false,
+    history: [],
+    completion: '',
+    value: '',
+
+    inputCommand: false,
+    cmd: null,
+    args: null,
+  });
+
+  init(prompt) {
+    const {state} = this;
+    state.prompt = prompt;
+  }
+
+  beginCommand(prompt, command) {
+    const {state} = this;
+    state.prompt = prompt;
+    state.busy = true;
+    state.history.push(`${prompt} ${command}`);
+  }
+
+  endCommand(prompt, result) {
+    const {state} = this;
+    state.prompt = prompt;
+    state.history.push(result);
+    state.busy = false;
+  }
+
+  inputCommand(input) {
+    const {state} = this;
+    state.history.push(input);
+    state.busy = true;
+    state.inputCommand = false;
+  }
+
+  forInputCommand(question, cmd, args) {
+    const {state} = this;
+    state.prompt = '-> ';
+    state.history.push(question);
+    state.busy = false;
+    state.inputCommand = true;
+    state.cmd = cmd;
+    state.args = args;
+  }
+
+  askForCompletion(prompt, input, tools) {
+    const {state} = this;
+    state.prompt = prompt;
+    if (tools.length > 1) {
+      state.completion = '';
+      state.history.push(
+        `${prompt} ${input}\n${tools
+          .filter((tool) => tool[0] !== '$')
+          .map((tool) => {
+            const items = tool.split(' ');
+            return items[items.length - 1];
+          })
+          .join(' ')}\n`
+      );
+    } else if (tools.length === 1) {
+      state.completion = tools[0];
+    } else {
+      state.completion = '';
+    }
+  }
+
+  setFromHistory(value) {
+    const {state} = this;
+    state.completion = value.trim();
+  }
+
+  clearCompletion() {
+    const {state} = this;
+    state.completion = '';
+  }
+
+  /// TOOLS ////////////////////////////////////////////////////////////////////
+
+  clear$tool() {
+    const {state} = this;
+    state.history = [];
+  }
+}
+
+function getTools(resp) {
+  const registry = resp.getCommandsRegistry();
+  return Object.fromEntries(
+    Object.entries(registry)
+      .filter(([cmd]) => cmd.endsWith('$tool'))
+      .map(([cmd, ctx]) => {
+        const tool = cmd.split('.').reverse()[0].split('$')[0];
+        return tool.length ? [tool, ctx] : [`$${cmd.split('.', 1)[0]}`, ctx];
+      })
+  );
+}
+
+function getTool(tools, name) {
+  if (name[0] !== '$' && name in tools) {
+    return tools[name];
+  }
+  throw new Error(`${name}: command not found`);
+}
+
+function getPrompt(user) {
+  return user.rank === 'admin' ? '~ #' : '~ $';
+}
+
+class Termux extends Elf.Alone {
+  logic = Elf.getLogic(TermuxLogic);
+  state = new TermuxState();
+
+  _unsub;
+  _tools = {};
+  _history = new OrderedSet(); /* only the command entries */
+
+  async init() {
+    const prompt = getPrompt(this.user);
+    this.logic.init(prompt);
+    const {resp} = this.quest;
+    this._tools = getTools(resp);
+    this._unsub = resp.onCommandsRegistry(() => {
+      this._tools = getTools(resp);
+    });
+    this.quest.goblin.defer(
+      this.quest.sub('*::*.<termux-input>', async (_, {msg}) => {
+        const {question, cmd, args} = msg.data;
+        await this.forInputCommand(question, cmd, args);
+      })
+    );
+  }
+
+  async beginCommand(command) {
+    const prompt = getPrompt(this.user);
+    this.quest.doSync({prompt, command});
+
+    const entries = parseOptions(command).map(
+      (option) =>
+        option
+          .replace(/^"(.*)"$/g, '$1')
+          .replace(/^'(.*)'$/g, '$1')
+          .replace(/\\([^\\])/g, '$1') /* unescape */
+          .replace(/\\\\/g, '\\') /* keep only escaped \ */
+    );
+    const name = entries[0];
+    const params = entries.slice(1);
+
+    let result = '';
+    try {
+      if (!name) {
+        return;
+      }
+
+      this._history.delete(command.trim());
+      this._history.add(command.trim());
+
+      const tool = getTool(this._tools, name);
+      const {required, optional} = tool.options.params;
+      let args = required.concat(optional).reduce((args, arg, index) => {
+        args[arg] = params[index];
+        return args;
+      }, {});
+      result = await this.quest.cmd(tool.name, args);
+    } catch (ex) {
+      result = ex.stack || ex.message || ex;
+    } finally {
+      /* Keep the command alive while te result is not a string.
+       * It uses with the <termux-input> stuff.
+       */
+      if (typeof result === 'string') {
+        if (result.length) {
+          result += '\n';
+        }
+        await this.endCommand(result);
+      }
+    }
+  }
+
+  async endCommand(result) {
+    const prompt = getPrompt(this.user);
+    this.logic.endCommand(prompt, result);
+  }
+
+  async inputCommand(input) {
+    const {state} = this;
+
+    this.logic.inputCommand(input);
+    if (!state.inputCommand || !state.cmd || !state.args) {
+      return;
+    }
+
+    let result = '';
+    try {
+      result = await this.quest.cmd(state.cmd, {input, ...state.args.toJS()});
+    } catch (ex) {
+      result = ex.stack || ex.message || ex;
+    }
+    if (typeof result === 'string') {
+      if (result.length) {
+        result += '\n';
+      }
+      await this.endCommand(result);
+    }
+  }
+
+  async forInputCommand(question, cmd, args) {
+    this.logic.forInputCommand(question, cmd, args);
+  }
+
+  async askForCompletion(input) {
+    const prompt = getPrompt(this.user);
+    const tools = Object.keys(this._tools).filter((tool) =>
+      tool.startsWith(input)
+    );
+    this.logic.askForCompletion(prompt, input, tools);
+
+    const {completion} = this.state;
+    if (completion) {
+      return;
+    }
+
+    const items = input.trim().split(' ');
+    const tool = items[0];
+    if (!(tool in this._tools)) {
+      return;
+    }
+
+    const name = this._tools[tool].name.split('.', 1)[0];
+    if (!(`$${name}` in this._tools)) {
+      return;
+    }
+
+    const desc = await this.quest.cmd(`${name}.$tool`, {tool});
+    if (items.length === 1) {
+      this.logic.askForCompletion(prompt, input, Object.keys(desc));
+      return;
+    }
+
+    const cmds = Object.keys(desc)
+      .filter((option) => option.startsWith(items[1]))
+      .map((option) => `${tool} ${option}`);
+    this.logic.askForCompletion(prompt, input.trim(), cmds);
+  }
+
+  async setFromHistory(up, input) {
+    let value;
+    input = input.trim();
+    if (up && !input) {
+      value = this._history.last();
+    } else if (input) {
+      value = up ? this._history.previous(input) : this._history.next(input);
+    }
+    if (!up && !value) {
+      this.logic.setFromHistory('<empty>');
+    } else if (value) {
+      this.logic.setFromHistory(value);
+    }
+  }
+
+  async clearCompletion() {
+    this.logic.clearCompletion();
+  }
+
+  /// TOOLS ////////////////////////////////////////////////////////////////////
+
+  async clear$tool() {
+    this.logic.clear$tool();
+    return '';
+  }
+
+  async man$tool(name) {
+    const tool = getTool(this._tools, name);
+    let result = '';
+    result += `  module: ${tool.info.name} (v${tool.info.version})\n`;
+    result += `location: ${tool.location}\n`;
+    result += `   usage: ${name} ${tool.options.params.required
+      .map((arg) => arg.toUpperCase())
+      .join(' ')}\n\n`;
+
+    /* List first parameter possible values */
+    const _name = tool.name.split('.', 1)[0];
+    if (`$${_name}` in this._tools) {
+      const desc = await this.quest.cmd(`${_name}.$tool`, {tool: name});
+      const {required} = tool.options.params;
+      if (required[0]) {
+        result += `${required[0].toUpperCase()} ${Object.keys(desc)
+          .filter((option) => option[0] !== '$')
+          .join(`\n${new Array(required[0].length + 2).join(' ')}`)}`;
+      }
+    }
+
+    return result;
+  }
+
+  async $tool(tool) {
+    if (tool === 'man') {
+      return {...this._tools};
+    }
+    return {};
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  dispose() {
+    if (this._unsub) {
+      this._unsub();
+    }
+  }
+}
+
+module.exports = {Termux, TermuxLogic};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goblin-laboratory",
-  "version": "4.6.5",
+  "version": "4.7.1",
   "description": "Laboratory",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -31,7 +31,8 @@
     "xcraft-core-log": "^2.2.0",
     "xcraft-core-probe": "^2.0.0",
     "xcraft-core-transport": "^4.0.0",
-    "xcraft-core-stones": "^0.4.16"
+    "xcraft-core-stones": "^0.4.16",
+    "xcraft-core-utils": "^4.19.0"
   },
   "devDependencies": {
     "aphrodite": "^2.2.2",

package/termux.js

@@ -0,0 +1,4 @@
+const {Elf} = require('xcraft-core-goblin');
+const {Termux, TermuxLogic} = require('./lib/termux.js');
+
+exports.xcraftCommands = Elf.birth(Termux, TermuxLogic);

package/test/termux.spec.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const {expect} = require('chai');
+const path = require('node:path');
+const {Elf} = require('xcraft-core-goblin/lib/test.js');
+const {TermuxLogic, Termux} = require('../lib/termux.js');
+
+describe('goblin.laboratory.termux.command', function () {
+  it('history', function () {
+    const termuxLogic = Elf.trial(TermuxLogic);
+
+    termuxLogic.beginCommand('$', 'cmd1', []);
+    termuxLogic.endCommand('done 1');
+    expect(termuxLogic.state.history.length).to.be.equal(2);
+    expect(termuxLogic.state.history[0]).to.be.equal('$ cmd1');
+    expect(termuxLogic.state.history[1]).to.be.equal('done 1');
+
+    termuxLogic.beginCommand('$', 'cmd2', []);
+    termuxLogic.endCommand('done 2');
+    expect(termuxLogic.state.history.length).to.be.equal(4);
+    expect(termuxLogic.state.history[2]).to.be.equal('$ cmd2');
+    expect(termuxLogic.state.history[3]).to.be.equal('done 2');
+  });
+});
+
+describe('goblin.laboratory.termux.completion', function () {
+  let runner;
+
+  this.beforeAll(function () {
+    runner = new Elf.Runner();
+    runner.init();
+  });
+
+  this.afterAll(function () {
+    runner.dispose();
+  });
+
+  it('history', async function () {
+    this.timeout(process.env.NODE_ENV === 'development' ? 1000000 : 40000);
+
+    /** @this {Elf} */
+    async function test() {
+      const xBus = require('xcraft-core-bus');
+      await xBus.loadModule(
+        this.quest.resp,
+        ['termux.js'],
+        path.join(__dirname, '..'),
+        {}
+      );
+
+      let state;
+      const termux = new Termux(this);
+
+      await termux.init();
+
+      await termux.beginCommand('cmd1');
+      await termux.endCommand('done 1');
+      await termux.beginCommand('cmd2');
+      await termux.endCommand('done 2');
+
+      //////////////////////////////////////////////////////////////////////////
+
+      await termux.setFromHistory(true, 'cmd2 '); // UP
+      state = await this.quest.getState('termux');
+      expect(state.get('completion')).to.be.equal('cmd1');
+
+      await termux.setFromHistory(true, 'cmd1 '); // UP (roof)
+      state = await this.quest.getState('termux');
+      expect(state.get('completion')).to.be.equal('cmd1');
+
+      await termux.setFromHistory(false, 'cmd1 '); // DOWN
+      state = await this.quest.getState('termux');
+      expect(state.get('completion')).to.be.equal('cmd2');
+
+      await termux.setFromHistory(false, 'cmd2 '); // DOWN (ground)
+      state = await this.quest.getState('termux');
+      expect(state.get('completion')).to.be.equal('<empty>');
+
+      //////////////////////////////////////////////////////////////////////////
+
+      await termux.setFromHistory(true, 'cmd3 '); // UP
+      state = await this.quest.getState('termux');
+      expect(state.get('completion')).to.be.equal('<empty>');
+
+      await termux.setFromHistory(false, 'cmd3 '); // DOWN
+      state = await this.quest.getState('termux');
+      expect(state.get('completion')).to.be.equal('<empty>');
+    }
+
+    await runner.it(test);
+  });
+});

package/widgets/laboratory/service.js

@@ -2,6 +2,7 @@
 
 const path = require('path');
 const Goblin = require('xcraft-core-goblin');
+const {Termux} = require('../../lib/termux.js');
 const goblinName = path.basename(module.parent.filename, '.js');
 
 // Define initial logic values
@@ -102,6 +103,11 @@ Goblin.registerQuest(goblinName, 'create', function* (
 
   const themeContexts = config.themeContexts || ['theme'];
 
+  config.feeds.push('termux');
+
+  const termux = new Termux(quest);
+  yield termux.init();
+
   const promises = [];
   for (const ctx of themeContexts) {
     const composerId = `theme-composer@${ctx}`;
@@ -521,6 +527,8 @@ Goblin.registerQuest(goblinName, 'del', function* (quest, widgetId) {
   }
 });
 
+/******************************************************************************/
+
 Goblin.registerQuest(goblinName, 'delete', function (quest) {
   unlisten(quest);
 });

package/widgets/laboratory/widget.js

@@ -1,10 +1,11 @@
 import React from 'react';
-import Widget from 'goblin-laboratory/widgets/widget';
-import Maintenance from 'goblin-laboratory/widgets/maintenance/widget';
+import Widget from '../widget';
+import Maintenance from '../maintenance/widget';
 import DisconnectOverlay from '../disconnect-overlay/widget';
-import ThemeContext from 'goblin-laboratory/widgets/theme-context/widget';
-
+import ThemeContext from '../theme-context/widget';
+import Termux from '../termux/widget.js';
 import importer from 'goblin_importer';
+
 const widgetImporter = importer('widget');
 
 class LaboratoryNC extends Widget {
@@ -13,22 +14,24 @@ class LaboratoryNC extends Widget {
   }
 
   renderContent() {
-    const {status, root, rootId, overlay, message} = this.props;
+    const {id, status, root, rootId, overlay, message} = this.props;
     if (status && status !== 'off') {
       return <Maintenance id="workshop" />;
-    } else {
-      const widgetName = root.split('@')[0];
-      const RootWidget = widgetImporter(widgetName);
-      if (overlay) {
-        return (
+    }
+
+    const widgetName = root.split('@')[0];
+    const RootWidget = widgetImporter(widgetName);
+    return (
+      <Termux labId={id}>
+        {overlay ? (
           <DisconnectOverlay message={message}>
             <RootWidget id={rootId} />
           </DisconnectOverlay>
-        );
-      } else {
-        return <RootWidget id={rootId} />;
-      }
-    }
+        ) : (
+          <RootWidget id={rootId} />
+        )}
+      </Termux>
+    );
   }
 
   render() {

package/widgets/termux/styles.js

@@ -0,0 +1,75 @@
+export default function styles() {
+  const fontColor = {
+    'color': 'rgb(200, 200, 200)',
+    '@media (prefers-color-scheme: light)': {
+      color: 'rgb(50, 50, 50)',
+    },
+  };
+
+  const console = {
+    'width': '100vw',
+    'height': 0,
+    'backgroundColor': 'rgba(0, 0, 0, 0.6)',
+    '@media (prefers-color-scheme: light)': {
+      backgroundColor: 'rgba(180, 180, 180, 0.6)',
+    },
+    'backdropFilter': 'blur(10px)',
+    'position': 'fixed',
+    'top': 0,
+    'left': 0,
+    'transition': 'height 0.2s ease-out, opacity 0.2s',
+    'opacity': 0,
+    'border': '5px solid transparent',
+
+    'display': 'flex',
+    'flexDirection': 'column',
+    'overflowY': 'scroll',
+    'pointerEvents': 'none',
+
+    'fontFamily': 'monospace',
+
+    '&[data-show=true]': {
+      pointerEvents: 'auto',
+      height: '50vh',
+      transition: 'height 0.1s ease-in, opacity 0.2s',
+      opacity: 1,
+    },
+
+    '& > .history': {
+      display: 'flex',
+      flexGrow: 1,
+      flexFlow: 'column-reverse',
+      fontSize: 'medium',
+      wordWrap: 'break-word',
+      ...fontColor,
+    },
+
+    '& > .cli': {
+      'display': 'flex',
+      'flexDirection': 'row',
+      'height': '15px',
+
+      '& > span': {
+        whiteSpace: 'nowrap',
+        ...fontColor,
+      },
+    },
+
+    '& > .cli > .input': {
+      'flexGrow': 1,
+      'width': '100%',
+      ...fontColor,
+      'border': 0,
+      'backgroundColor': 'transparent',
+      'fontSize': 'medium',
+
+      '&:focus': {
+        outline: 'none',
+      },
+    },
+  };
+
+  return {
+    console,
+  };
+}

package/widgets/termux/widget.js

@@ -0,0 +1,243 @@
+import React from 'react';
+import Widget from 'goblin-laboratory/widgets/widget';
+import Mousetrap from 'mousetrap';
+import * as styles from './styles.js';
+
+class TermuxNC extends Widget {
+  scrollTimeout;
+
+  constructor() {
+    super(...arguments);
+    this.styles = styles;
+    this.inputRef = React.createRef();
+
+    this.state = {
+      show: false,
+      value: '',
+    };
+  }
+
+  scrollToBottom() {
+    if (this.inputRef.current) {
+      this.inputRef.current.scrollIntoView();
+    }
+  }
+
+  componentDidMount() {
+    Mousetrap.bind('alt+f12', this.toggleConsole);
+  }
+
+  componentWillUnmount() {
+    super.componentWillUnmount();
+    Mousetrap.unbind('alt+f12');
+    if (this.scrollTimeout) {
+      clearTimeout(this.scrollTimeout);
+      this.scrollTimeout = null;
+    }
+  }
+
+  componentDidUpdate(prevProps) {
+    const {completion} = this.props;
+    if (completion && prevProps.completion !== completion) {
+      this.setState({
+        value: completion === '<empty>' ? '' : this.props.completion + ' ',
+      });
+      this.clearCompletion();
+    }
+  }
+
+  toggleConsole = () => {
+    this.setState({show: !this.state.show});
+  };
+
+  askForCompletion = () => {
+    const input = this.inputRef.current?.value;
+    this.doFor('termux', 'askForCompletion', {input});
+  };
+
+  setFromHistory = (up) => {
+    const input = this.inputRef.current?.value;
+    this.doFor('termux', 'setFromHistory', {up, input});
+  };
+
+  clearCompletion = () => {
+    this.doFor('termux', 'clearCompletion');
+  };
+
+  beginCommand = (command) => {
+    this.doFor('termux', 'beginCommand', {command});
+  };
+
+  inputCommand = (input) => {
+    this.doFor('termux', 'inputCommand', {input});
+  };
+
+  setCliFocus = () => {
+    setTimeout(() => this.inputRef.current?.focus());
+  };
+
+  handleKeyDown = (event) => {
+    switch (event.key) {
+      /* Valid the command line */
+      case 'Enter': {
+        const {value} = this.state;
+        const {inputCommand} = this.props;
+        if (inputCommand) {
+          this.inputCommand(value);
+        } else {
+          this.beginCommand(value);
+        }
+        this.setState({value: ''});
+        break;
+      }
+      /* Show or hide the console */
+      case 'F12': {
+        if (event.altKey) {
+          event.preventDefault();
+          this.toggleConsole();
+        }
+        break;
+      }
+      /* Try to autocomplete */
+      case 'Tab': {
+        event.preventDefault();
+        this.askForCompletion();
+        break;
+      }
+      /* Move into the command history */
+      case 'ArrowUp':
+      case 'ArrowDown': {
+        event.preventDefault();
+        this.setFromHistory(event.key === 'ArrowUp');
+        break;
+      }
+      /* [a] move to the begining, [e] move to the end */
+      case 'a':
+      case 'e': {
+        if (event.ctrlKey) {
+          event.preventDefault();
+          if (event.key === 'a') {
+            this.inputRef.current.setSelectionRange(0, 0);
+          } else if (event.key === 'e') {
+            const {length} = this.inputRef.current.value;
+            this.inputRef.current.setSelectionRange(length, length);
+          }
+          this.inputRef.current.focus();
+        }
+        break;
+      }
+      /* Erase the whole line */
+      case 'u': {
+        if (event.ctrlKey) {
+          this.setState({value: ''});
+        }
+        break;
+      }
+      /* Remove the previous word */
+      case 'w': {
+        if (event.ctrlKey) {
+          const values = this.state.value.split(' ');
+          const value = values.slice(0, -1).join(' ');
+          this.setState({value});
+        }
+        break;
+      }
+    }
+
+    /* Handle scroll with a timeout because (just after the send, the new state
+     * is not available)
+     */
+    this.scrollToBottom();
+    if (this.scrollTimeout) {
+      clearTimeout(this.scrollTimeout);
+    }
+    this.scrollTimeout = setTimeout(() => {
+      this.scrollToBottom();
+    }, 100);
+  };
+
+  renderCli() {
+    const {prompt, busy} = this.props;
+    return (
+      <div className="cli">
+        {busy ? (
+          <span>&nbsp;</span>
+        ) : (
+          <>
+            <span>{prompt}&nbsp;</span>
+            <input
+              className="input"
+              type="text"
+              onKeyDown={this.handleKeyDown}
+              autoFocus
+              ref={this.inputRef}
+              value={this.state.value}
+              onChange={(e) => this.setState({value: e.target.value})}
+            ></input>
+          </>
+        )}
+      </div>
+    );
+  }
+
+  renderHistory() {
+    return (
+      <div className="history" onMouseDown={this.setCliFocus}>
+        {this.props.history.reverse().map((row, index) => (
+          <span key={index}>
+            {row.split('\n').map((row, index) => (
+              <span key={index}>
+                {row.replaceAll(' ', ' ')}
+                <br />
+              </span>
+            ))}
+          </span>
+        ))}
+      </div>
+    );
+  }
+
+  renderConsole() {
+    return (
+      <>
+        {this.renderHistory()}
+        {this.renderCli()}
+      </>
+    );
+  }
+
+  render() {
+    const {children} = this.props;
+    const {show} = this.state;
+    return (
+      <>
+        {children}
+        <div className={this.styles.classNames.console} data-show={show}>
+          {show ? this.renderConsole() : null}
+        </div>
+      </>
+    );
+  }
+}
+
+const Termux = Widget.connect((state, props) => {
+  const termux = state.get('backend').get('termux');
+  if (!termux) {
+    return {
+      prompt: '~ $',
+      busy: true,
+      history: [],
+      completion: '',
+      inputCommand: false,
+    };
+  }
+  return {
+    prompt: termux.get('prompt', '~ $'),
+    busy: termux.get('busy', false),
+    history: termux.get('history', []),
+    completion: termux.get('completion', ''),
+    inputCommand: termux.get('inputCommand', false),
+  };
+})(TermuxNC);
+
+export default Termux;