utilitas 1990.1.28 → 1990.1.31

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,46 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  version:
+    runs-on: ubuntu-latest
+    if: "!startsWith(github.event.head_commit.message, '[RELEASE]')"
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - run: git config --global user.name 'Leask Wong'
+      - run: git config --global user.email 'i@leaskh.com'
+      - run: npm version patch -m "[RELEASE] %s"
+      - run: git push
+
+  build:
+    runs-on: ubuntu-latest
+    needs: version
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/README.md

@@ -8,3 +8,5 @@ Works in Node.js and modern browsers.
 
 tbd...
 ## TOTO
+
+tbd...

package/lib/bot.mjs

@@ -4,9 +4,10 @@ import { ensureArray, insensitiveCompare, log as _log } from './utilitas.mjs';
 import { join } from 'path';
 import { readdirSync } from 'fs';
 import { Telegraf } from 'telegraf';
+import cluster from 'cluster';
 
 const signals = ['SIGINT', 'SIGTERM'];
-const provider = 'TELEGRAM';
+const [BOT_SEND, provider, MESSAGE] = ['BOT_SEND', 'TELEGRAM', 'message'];
 const iCmp = (strA, strB) => ~~insensitiveCompare(strA, strB, { w: true });
 const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
 const end = async (options) => bot && bot.stop(options?.signal);
@@ -56,34 +57,49 @@ const init = async (options) => {
             insensitiveCompare(options?.provider, provider),
             'Invalid bot provider.', 501
         );
-        bot = new Telegraf(options?.botToken);
-        const [mods, pmsTrain] = [[{
-            ...subconscious, run: !options?.silent
-        }, ...ensureArray(options?.skill)], []];
-        for (let skillPath of ensureArray(options?.skillPath)) {
-            log(`SKILLS: ${skillPath}`);
-            const files = (readdirSync(skillPath) || []).filter(
-                file => /\.mjs$/i.test(file) && !file.startsWith('.')
-            );
-            for (let f of files) {
-                const m = await import(join(skillPath, f));
-                mods.push({ ...m, name: m.name || f.replace(/^(.*)\.mjs$/i, '$1') });
+        if (cluster.isPrimary) {
+            bot = new Telegraf(options?.botToken);
+            const [mods, pmsTrain] = [[{
+                ...subconscious, run: !options?.silent
+            }, ...ensureArray(options?.skill)], []];
+            for (let skillPath of ensureArray(options?.skillPath)) {
+                log(`SKILLS: ${skillPath}`);
+                const files = (readdirSync(skillPath) || []).filter(
+                    file => /\.mjs$/i.test(file) && !file.startsWith('.')
+                );
+                for (let f of files) {
+                    const m = await import(join(skillPath, f));
+                    mods.push({ ...m, name: m.name || f.replace(/^(.*)\.mjs$/i, '$1') });
+                }
             }
+            mods.map(mod => { mod.run && pmsTrain.push(load(bot, mod, options)) });
+            assert(pmsTrain.length, 'Invalid skill set.', 501);
+            await Promise.all(pmsTrain);
+            bot.launch();
+            cluster.on(MESSAGE, (worker, msg) => eventHandler(msg));
+            // Graceful stop
+            signals.map(signal => process.once(signal, () => bot.stop(signal)));
+        } else {
+            bot = {
+                telegram: {
+                    sendMessage: (...args) =>
+                        process.send({ action: BOT_SEND, data: args })
+                }
+            };
         }
-        mods.map(mod => { mod.run && pmsTrain.push(load(bot, mod, options)) });
-        assert(pmsTrain.length, 'Invalid skill set.', 501);
-        await Promise.all(pmsTrain);
-        bot.launch();
-        // Graceful stop
-        signals.map(signal => process.once(signal, () => bot.stop(signal)));
     }
     assert(bot, 'Bot have not been initialized.', 501);
     return bot;
 };
 
-const send = async (chatId, content, options) => (
-    await init()
-).telegram.sendMessage(chatId, content);
+const send = async (chatId, content, options) =>
+    (await init()).telegram.sendMessage(chatId, content);
+
+const eventHandler = async (msg) => {
+    switch (msg?.action) {
+        case BOT_SEND: return await send(...msg?.data || []);
+    }
+};
 
 export default init;
 export {

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1990.1.28",
+    "version": "1990.1.29",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",
@@ -16,7 +16,7 @@ const manifest = {
         "url": "https://github.com/Leask/utilitas.git"
     },
     "dependencies": {
-        "@sentry/node": "^6.19.6",
+        "@sentry/node": "^6.19.7",
         "base64url": "^3.0.1",
         "buffer": "^6.0.3",
         "fast-geoip": "^1.1.68",

package/lib/network.mjs

@@ -4,7 +4,8 @@ import { ensureArray, log as _log, throwError } from './utilitas.mjs';
 import { getCurrentIp } from './shot.mjs';
 import { lookup } from 'fast-geoip';
 
-const log = (content) => _log(content, import.meta.url);
+const isLocalhost = host => ['127.0.0.1', '::1', 'localhost'].includes(host);
+const log = content => _log(content, import.meta.url);
 
 const ping = async (host, options = { timeout: 3, min_reply: 3 }) => {
     await assertExist('ping');
@@ -94,6 +95,7 @@ const getCurrentPosition = async () => {
 export {
     getCurrentPosition,
     httping,
+    isLocalhost,
     pickFastestHost,
     pickFastestHttpServer,
     ping,

package/lib/shot.mjs

@@ -63,7 +63,7 @@ const get = async (url, options) => {
     ) : [];
     const meta = options?.refresh || !base ? null : await readJson(cacheMeta);
     const cache = options?.refresh || !base ? null : await ignoreErrFunc(
-        async () => { return await fs.readFile(cacheCont); }
+        () => fs.readFile(cacheCont)
     );
     const headers = meta?.responseHeaders && cache ? {
         'cache-control': 'max-age=0',
@@ -75,7 +75,7 @@ const get = async (url, options) => {
     if (options.timeout) {
         const controller = new AbortController();
         fetchOptions.signal = controller.signal;
-        timer = setTimeout(() => { controller.abort(); }, options.timeout);
+        timer = setTimeout(() => controller.abort(), options.timeout);
     }
     try { r = await fetch(url, fetchOptions); } catch (e) {
         throwError(e.message.includes('aborted') ? 'Timed out.' : e.message, 500);

package/lib/storage.mjs

@@ -1,4 +1,4 @@
-import { constants, promises as fs, readSync } from 'fs';
+import { constants as consts, promises as fs, readSync } from 'fs';
 import { ensureString, mergeAtoB, throwError, trim, which } from './utilitas.mjs';
 import { join } from 'path';
 import { parse as iniParse, stringify as iniStringify } from 'ini';
@@ -45,42 +45,27 @@ const writeTempFile = async (data, options) => {
     return filepath;
 };
 
-const assertPath = async (path, type, mode, message, status = 500, options = {}) => {
-    let [stat, typeErr, modeErr] = [null, null, null];
-    try { stat = await fs.stat(path); } catch (err) {
-        throwError(message || err.message, status, options);
-    }
+const assertPath = async (path, type, mode, msg, code, options) => {
+    var [code, b, E, s, err] = [code || 500, 'Path is not', m => err = msg || m];
+    try { s = await fs.stat(path); }
+    catch (e) { throwError(msg || e.message, code, options); }
     switch (String(type || '').toUpperCase()) {
-        case '*': case '':
-            break;
-        case 'F':
-            typeErr = stat.isFile()
-                ? null : (message || `Path is not a file: '${path}'.`);
-            break;
-        case 'D':
-            typeErr = stat.isDirectory()
-                ? null : (message || `Path is not a directory: '${path}'.`);
-            break;
-        default:
-            typeErr = message || `Unsupported path type: '${type}'.`;
+        case '*': case '': break;
+        case 'F': s.isFile() || E(`${b} a file: '${path}'.`); break;
+        case 'D': s.isDirectory() || E(`${b} a directory: '${path}'.`); break;
+        default: E(`Unsupported path type: '${type}'.`);
     }
-    assert(!typeErr, typeErr, status, options);
+    assert(!err, err, code, options);
     try {
         switch (String(mode || '').toUpperCase()) {
-            case '*': case '':
-                break;
-            case 'R':
-                await fs.access(path, constants.R_OK);
-                break;
-            case 'W':
-                await fs.access(path, constants.R_OK | constants.W_OK);
-                break;
-            default:
-                modeErr = message || `Unsupported access mode: '${mode}'.`;
+            case '*': case '': break;
+            case 'R': await fs.access(path, consts.R_OK); break;
+            case 'W': await fs.access(path, consts.R_OK | consts.W_OK); break;
+            default: E(`Unsupported access mode: '${mode}'.`);
         };
-    } catch (err) { modeErr = message || err.message; }
-    assert(!modeErr, modeErr, status, options);
-    return stat;
+    } catch (e) { E(e.message); }
+    assert(!err, err, code, options);
+    return s;
 };
 
 const isTextFile = async (filename, options) => {

package/lib/tape.mjs

@@ -10,10 +10,10 @@ const consoleMap = ['log', 'info', 'debug', 'warn', 'error'];
 const trace = { trace: true };
 const [TAPE, BOT] = ['TAPE', 'BOT'];
 const [maxLength, defBufCycle, maxBufCycle] = [4096, 10, 100];
-const stdout = (message) => process.stdout.write(`${message}\n`);
+const stdout = message => process.stdout.write(`${message}\n`);
 const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
-const getSendTxt = (arr) => arr.map(x => x[1]).join('\n');
-const getSndSize = (arr) => getSendTxt(arr).length;
+const getSendTxt = arr => arr.map(x => x[1]).join('\n');
+const getSndSize = arr => getSendTxt(arr).length;
 const getBufSize = () => maxLength * bufferCycle;
 const nextLen = () => botBuffer?.[0]?.[1].length || (maxLength + 1);
 const stringify = any => ensureString(any, trace);

package/lib/utilitas.mjs

@@ -1,5 +1,5 @@
-import { basename as _basename, dirname, join } from 'path';
-import { readJson } from './storage.mjs';
+import { assertPath, readJson, } from './storage.mjs';
+import { basename as _basename, dirname, join, sep } from 'path';
 import { validate as verifyUuid } from 'uuid';
 import color from './color.mjs';
 
@@ -292,15 +292,21 @@ const log = (content, filename, options) => {
 
 const which = async (any) => {
     if (!Object.isObject(any)) {
-        any = any || process.argv[1];
+        any = any || import.meta.url;
         any = any.startsWith('file://') ? fileURLToPath(any) : any;
         if (!any?.endsWith?.('.json')) {
-            any = /\.[mc]?js$/i.test(any) ? dirname(any) : any;
-            any = join(any, 'package.json');
+            any = ['/', ...any.split(sep).slice(1)];
+            const arrPath = [];
+            for (let sub of any) {
+                arrPath.push(sub);
+                const curPath = join(...arrPath, 'package.json');
+                try { await assertPath(curPath, 'F', 'R'); any = curPath; break; }
+                catch (e) { }
+            }
         }
         any = await readJson(any);
     }
-    any.name = any.name || _basename(dirname(process.argv[1])) || '';
+    any.name = any.name || '';
     any.versionNormalized = parseVersion(any.version = any.version || '');
     any.title = `${any.name}${any.version ? (' v' + any.version) : ''}`;
     any.userAgent = `${any.name}${any.version ? `/${any.version}` : ''}`;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1990.1.28",
+    "version": "1990.1.31",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",
@@ -17,7 +17,7 @@
         "gitsync": "( git commit -am \"Released @ `date`\" || true ) && git pull && git push",
         "pack": "./node_modules/.bin/webpack-cli --config webpack.config.mjs",
         "build": "npm run updep && ( git commit -am 'update dependencies' || true ) && npm version patch && node build.mjs && npm run pack",
-        "prepublishOnly": "npm run build && npm run gitsync",
+        "xprepublishOnly": "npm run build && npm run gitsync",
         "beta": "npm publish --tag beta"
     },
     "author": "Leask Wong <i@leaskh.com>",
@@ -27,7 +27,7 @@
         "url": "https://github.com/Leask/utilitas.git"
     },
     "dependencies": {
-        "@sentry/node": "^6.19.6",
+        "@sentry/node": "^6.19.7",
         "base64url": "^3.0.1",
         "buffer": "^6.0.3",
         "fast-geoip": "^1.1.68",