theamify-cli 2.0.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theamify-cli",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "theamify — GRUB theme manager & interactive browser wizard. Browse, preview, download and apply GRUB boot themes from the terminal.",
   "type": "module",
   "main": "src/cli.js",

package/src/cli.js

@@ -2,7 +2,7 @@ import { defineCommand, runMain } from 'citty';
 import pc from 'picocolors';
 import { createRequire } from 'node:module';
 import { runThemeBrowser } from './wizard/browse.js';
-import { runDoctor, runStatus, runUninstallWizard } from './commands/manage.js';
+import { runDoctor, runStatus, runUninstallWizard, runSelfUpgrade, runRepair } from './commands/manage.js';
 import { updateManagedTools } from './lib/tools.js';
 import { runEngine } from './core/engine.js';
 
@@ -10,7 +10,7 @@ const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 
 /** Commands forwarded straight to the bash engine. */
-const ENGINE_COMMANDS = ['list', 'ls', 'info', 'show', 'get', 'fetch', 'download', 'remove', 'rm', 'uncache', 'add', 'del', 'delete', 'update', 'open', 'browse', 'clean', 'purge-cache', 'help', '-h', '-V', '--version'];
+const ENGINE_COMMANDS = ['list', 'ls', 'info', 'show', 'get', 'fetch', 'download', 'remove', 'rm', 'uncache', 'add', 'del', 'delete', 'update', 'open', 'clean', 'purge-cache'];
 
 /**
  * Forward argv to the bash engine and mirror its exit status onto this process.
@@ -42,7 +42,9 @@ ${pc.bold('Usage:')}
   theamify open <name>        Open the theme source page in a browser
   theamify status             Show GRUB & dependency status
   theamify doctor             Diagnose install, GRUB & dependencies
-  theamify uninstall          Remove theamify (asks before deleting anything)
+  theamify upgrade            Check for & install the latest npm version
+  theamify repair             Fix a broken install (re-provision the engine)
+  theamify uninstall          Remove theamify entirely (incl. npm package)
   theamify clean              Clear the repo clone cache
 `);
 }
@@ -78,10 +80,30 @@ const main = defineCommand({
       case 'wizard':
       case 'browse':
         return runThemeBrowser();
+      case 'install':
+        // Guided setup: companion tools → download all themes.
+        return runThemeBrowser();
+      case 'help':
+      case '-h':
+      case '--help':
+        printUsage();
+        return;
+      case 'version':
+      case '-v':
+      case '-V':
+      case '--version':
+        console.log(`theamify v${pkg.version}`);
+        return;
       case 'status':
         return runStatus();
       case 'doctor':
         return runDoctor();
+      case 'upgrade':
+      case 'self-update':
+      case 'selfupdate':
+        return runSelfUpgrade();
+      case 'repair':
+        return runRepair();
       case 'uninstall':
         return runUninstallWizard();
       case 'update':

package/src/commands/manage.js

@@ -6,11 +6,13 @@ import { execa, execaSync } from 'execa';
 import {
   findInstalledRuntime,
   USER_DIR,
-  USER_BIN_LINK,
+  removeShadowBin,
+  repairRuntime,
   resolveEngine,
 } from '../core/engine.js';
 import { parseThemes, resolveConfPath } from '../lib/conf.js';
 import { companionToolStatus } from '../lib/tools.js';
+import { checkForUpdate, promptSelfUpdate, selfUninstall } from '../lib/self.js';
 
 /** `theamify doctor` — installation, GRUB and dependency health. */
 export async function runDoctor() {
@@ -80,7 +82,85 @@ export async function runStatus() {
   if (res.exitCode !== 0) process.exit(res.exitCode);
 }
 
-/** `theamify uninstall` — interactive, every destructive step confirmed. */
+/** `theamify upgrade` — self-update the npm CLI if a newer version is published. */
+export async function runSelfUpgrade() {
+  const { outdated, latest, current } = await checkForUpdate();
+  if (!outdated) {
+    console.log(pc.green(`Already on the latest version (v${current}).`));
+    return;
+  }
+  console.log(`Available: ${pc.cyan('v' + latest)}  (you have ${pc.dim('v' + current)})`);
+  await promptSelfUpdate();
+}
+
+/** `theamify repair` — fix a broken install by re-provisioning the engine/runtime. */
+export async function runRepair() {
+  console.log(pc.bold('\n🔧 theamify Repair\n'));
+  const engine = await repairRuntime();
+  console.log(`  Engine   : ${pc.cyan(engine)}`);
+  console.log(`  Runtime  : ${pc.cyan(path.join(USER_DIR))}`);
+  console.log('  Status   : ' + pc.green('engine re-provisioned'));
+  console.log('  Downloads: ' + (fs.existsSync(path.join(USER_DIR, 'themes')) ? pc.green('themes preserved') : pc.dim('no cached themes yet')));
+  console.log();
+}
+
+/**
+ * Remove a theamify runtime directory and everything in it (the engine PLUS all
+ * downloaded themes under themes/ and .repo_cache/). Uses sudo when the dir is
+ * root-owned.
+ * @param {string} dir absolute path to the runtime dir
+ * @returns {Promise<boolean>} true when the dir no longer exists
+ */
+export async function removeRuntimeDir(dir) {
+  if (!fs.existsSync(dir)) return true;
+  try {
+    const owner = fs.statSync(dir).uid;
+    if (owner === 0 && process.getuid() !== 0) {
+      const res = await execa('sudo', ['rm', '-rf', dir], { stdio: 'inherit', reject: false });
+      return res.exitCode === 0 && !fs.existsSync(dir);
+    }
+    fs.rmSync(dir, { recursive: true, force: true });
+    return !fs.existsSync(dir);
+  } catch {
+    return false;
+  }
+}
+
+/** Build the bash script that clears GRUB_THEME and rebuilds the boot menu. */
+export function buildResetGrubScript(grubFile = '/etc/default/grub') {
+  return `
+GRUB=${grubFile}
+[ -f "$GRUB" ] || exit 0
+sed -i '/^GRUB_THEME=/d' "$GRUB"
+if command -v update-grub >/dev/null 2>&1; then
+  update-grub
+elif command -v grub-mkconfig >/dev/null 2>&1; then
+  grub-mkconfig -o /boot/grub/grub.cfg
+elif command -v grub2-mkconfig >/dev/null 2>&1; then
+  grub2-mkconfig -o /boot/grub2/grub.cfg
+fi
+`.trim();
+}
+
+/**
+ * Remove GRUB_THEME from /etc/default/grub and rebuild the boot menu so the
+ * system returns to the default theme. Requires sudo when not root.
+ * @param {{grubFile?:string, asRoot?:boolean}} [opts] injectable for tests
+ * @returns {Promise<boolean>} true when GRUB was reset
+ */
+export async function resetGrubTheme({ grubFile = '/etc/default/grub', asRoot = process.getuid() === 0 } = {}) {
+  const script = buildResetGrubScript(grubFile);
+  if (asRoot) {
+    const res = await execa('bash', ['-c', script], { stdio: 'inherit', reject: false });
+    return res.exitCode === 0;
+  }
+  // Release the terminal so the sudo password prompt is visible & interruptible.
+  console.log();
+  const res = await execa('sudo', ['bash', '-c', script], { stdio: 'inherit', reject: false });
+  return res.exitCode === 0;
+}
+
+/** `theamify uninstall` — removes theamify, ALL downloaded themes, and resets GRUB to default. */
 export async function runUninstallWizard() {
   p.intro(pc.bgRed(pc.black(' theamify Uninstaller ')));
   const found = findInstalledRuntime();
@@ -89,39 +169,34 @@ export async function runUninstallWizard() {
   let removed = false;
   if (found) {
     const confirm = await p.confirm({
-      message: `Remove theamify files at ${found.dir}/?`,
+      message: `Remove theamify files at ${found.dir}/? (this deletes ALL downloaded themes)`,
       initialValue: true,
     });
     if (!p.isCancel(confirm) && confirm) {
-      try {
-        const dir = found.dir;
-        const owner = fs.statSync(dir).uid;
-        if (owner === 0 && process.getuid() !== 0) {
-          await execa('sudo', ['rm', '-rf', dir], { stdio: 'inherit' });
-        } else {
-          fs.rmSync(dir, { recursive: true, force: true });
-        }
-        removed = true;
-        // remove the PATH symlink arm (never touches ~/.bashrc blocks without asking? leave PATH block — it's harmless)
-        if (USER_BIN_LINK.startsWith(USER_DIR)) {
-          fs.rmSync(USER_BIN_LINK, { force: true });
-        }
-      } catch {
-        p.log.warn(`Could not remove ${found.dir}.`);
-      }
+      removed = await removeRuntimeDir(found.dir);
+      if (removed) removeShadowBin();
+      else p.log.warn(`Could not remove ${found.dir}.`);
     }
   }
 
-  const keepGrub = await p.confirm({
-    message: 'Keep your currently-applied GRUB theme? (recommended)',
+  // Reset the boot menu back to the default (remove the applied GRUB theme).
+  const resetGrub = await p.confirm({
+    message: 'Remove your applied GRUB theme and reset to the default boot menu?',
     initialValue: true,
   });
-  if (p.isCancel(keepGrub)) { p.cancel('Aborted.'); process.exit(0); }
+  if (p.isCancel(resetGrub)) { p.cancel('Aborted.'); process.exit(0); }
+  const grubReset = resetGrub ? await resetGrubTheme() : false;
+
+  // Remove the npm package so the `theamify` command actually disappears.
+  const npmRemoved = await selfUninstall();
 
   // Companion tools (chafa, grub-customizer) are intentionally LEFT in place —
   // the user may want them for later; uninstall only removes theamify itself.
+  const themeNote = grubReset
+    ? 'Boot menu reset to the default theme.'
+    : (resetGrub ? 'GRUB reset could not be completed — remove GRUB_THEME= from /etc/default/grub and rebuild.' : 'Your applied GRUB theme was left in place.');
 
   p.outro(pc.green(
-    `Uninstalled.${removed ? ' Runtime removed.' : ''}${keepGrub ? ' Active GRUB theme left in place.' : ' To revert GRUB, remove GRUB_THEME= from /etc/default/grub and rebuild.'} Companion tools (chafa, grub-customizer) were kept for your use.`,
+    `Uninstalled.${removed ? ' Runtime + all downloaded themes removed.' : ''} ${themeNote} ${npmRemoved ? 'theamify npm package removed — command no longer available.' : 'theamify npm package kept.'} Companion tools (chafa, grub-customizer) were kept for your use.`,
   ));
 }

package/src/core/engine.js

@@ -14,6 +14,7 @@ export const ENGINE_SCRIPT = path.join(VENDOR_DIR, 'theamify');
 export const SYSTEM_DIR = '/usr/local/share/theamify';
 export const USER_DIR = path.join(os.homedir(), '.local', 'share', 'theamify');
 export const BIN_NAME = 'theamify';
+/** Legacy self-shadowing symlink that used to point at the bundled bash engine. */
 export const USER_BIN_LINK = path.join(os.homedir(), '.local', 'bin', BIN_NAME);
 
 /**
@@ -27,51 +28,88 @@ export function findInstalledRuntime() {
   return null;
 }
 
+/**
+ * Remove the legacy `~/.local/bin/theamify` symlink if it exists. It was created
+ * by old installs to point at the bundled bash engine, which SHADOWS the npm CLI
+ * (because `~/.local/bin` precedes the npm global bin on PATH — so `theamify`,
+ * `theamify uninstall`, `theamify doctor`, etc. silently ran the old engine).
+ * The npm package already installs `theamify -> bin/theamify.js` in the npm
+ * global bin, which is on PATH, so the symlink is unnecessary and harmful.
+ * Only ever removes a symlink — never a real file the user owns.
+ */
+export function removeShadowBin() {
+  try {
+    const st = fs.lstatSync(USER_BIN_LINK);
+    if (st.isSymbolicLink()) fs.rmSync(USER_BIN_LINK, { force: true });
+  } catch { /* nothing to remove */ }
+}
+
+/** Copy the vendored engine script + shared libs into a runtime dir. */
+function copyEngineTo(dir) {
+  fs.mkdirSync(path.join(dir, 'lib'), { recursive: true });
+  fs.copyFileSync(path.join(VENDOR_DIR, BIN_NAME), path.join(dir, BIN_NAME));
+  fs.chmodSync(path.join(dir, BIN_NAME), 0o755);
+  for (const lib of ['colors', 'utils', 'grub', 'themes']) {
+    fs.copyFileSync(path.join(VENDOR_DIR, 'lib', `${lib}.sh`), path.join(dir, 'lib', `${lib}.sh`));
+  }
+}
+
+/**
+ * Refreshes an existing installed runtime's engine script + libs to match the
+ * bundled package (so the disk engine is never a stale older version). User
+ * registry edits in config/themes.conf are preserved.
+ */
+function syncEngineTo(dir) {
+  const installed = path.join(dir, BIN_NAME);
+  const vendored = path.join(VENDOR_DIR, BIN_NAME);
+  try {
+    if (fs.existsSync(installed) && fs.readFileSync(installed, 'utf8') !== fs.readFileSync(vendored, 'utf8')) {
+      copyEngineTo(dir);
+    }
+  } catch {
+    copyEngineTo(dir);
+  }
+}
+
 /**
  * Provision a user-owned install of the engine under ~/.local/share/theamify so
  * it is writable without root (downloads write into themes/ and .repo_cache/).
- * Preserves an existing config/themes.conf (user registry edits). Returns the
+ * Preserves an existing config/themes.conf (user registry edits). Does NOT create
+ * a PATH shadow symlink — the npm global bin is already on PATH. Returns the
  * runtime dir.
  */
 export async function installUserRuntime() {
-  const { execaSync } = await import('execa');
-  fs.mkdirSync(path.join(USER_DIR, 'lib'), { recursive: true });
   fs.mkdirSync(path.join(USER_DIR, 'config'), { recursive: true });
   fs.mkdirSync(path.join(USER_DIR, 'themes'), { recursive: true });
   fs.mkdirSync(path.join(USER_DIR, '.repo_cache'), { recursive: true });
 
-  fs.copyFileSync(path.join(VENDOR_DIR, BIN_NAME), path.join(USER_DIR, BIN_NAME));
-  fs.chmodSync(path.join(USER_DIR, BIN_NAME), 0o755);
-  for (const lib of ['colors', 'utils', 'grub', 'themes']) {
-    fs.copyFileSync(path.join(VENDOR_DIR, 'lib', `${lib}.sh`), path.join(USER_DIR, 'lib', `${lib}.sh`));
-  }
+  copyEngineTo(USER_DIR);
   const confSrc = path.join(VENDOR_DIR, 'config', 'themes.conf');
   const confDst = path.join(USER_DIR, 'config', 'themes.conf');
   if (!fs.existsSync(confDst)) {
     fs.copyFileSync(confSrc, confDst);
   }
 
-  // The installed engine expects a wrapping bin symlink so `sudo theamify` works.
-  fs.mkdirSync(path.dirname(USER_BIN_LINK), { recursive: true });
-  fs.rmSync(USER_BIN_LINK, { force: true });
-  fs.symlinkSync(path.join(USER_DIR, BIN_NAME), USER_BIN_LINK);
-
-  // Ensure a PATH marker so the command is reachable from a fresh shell.
-  await ensureOnPath(path.dirname(USER_BIN_LINK));
+  removeShadowBin();
   return USER_DIR;
 }
 
-/** Add a PATH export marker to ~/.bashrc and ~/.zshrc (idempotent). */
-export function ensureOnPath(binDir) {
-  const marker = '# theamify CLI PATH';
-  const rcs = ['.bashrc', '.zshrc'].map((f) => path.join(os.homedir(), f));
-  for (const rc of rcs) {
-    try {
-      const content = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
-      if (content.includes(marker)) continue;
-      fs.appendFileSync(rc, `\n${marker}\nexport PATH="${binDir}:$PATH"\n`);
-    } catch { /* skip */ }
+/**
+ * Repair a broken install: re-provision the engine/runtime from the bundled
+ * package (fixes a missing/corrupt engine or runtime tree) and remove any stale
+ * shadow symlink. Downloads are preserved unless the whole runtime is missing.
+ * @returns {Promise<string>} path to the repaired engine
+ */
+export async function repairRuntime() {
+  const found = findInstalledRuntime();
+  if (found) {
+    syncEngineTo(found.dir);
+    removeShadowBin();
+    return path.join(found.dir, BIN_NAME);
   }
+  const dir = await installUserRuntime();
+  removeShadowBin();
+  return path.join(dir, BIN_NAME);
 }
 
 /**
@@ -82,8 +120,13 @@ export function ensureOnPath(binDir) {
  */
 export async function resolveEngine() {
   const found = findInstalledRuntime();
-  if (found) return path.join(found.dir, BIN_NAME);
+  if (found) {
+    syncEngineTo(found.dir);
+    removeShadowBin();
+    return path.join(found.dir, BIN_NAME);
+  }
   const dir = await installUserRuntime();
+  removeShadowBin();
   return path.join(dir, BIN_NAME);
 }
 
@@ -97,4 +140,4 @@ export async function runEngine(args = []) {
   const { execa } = await import('execa');
   const engine = await resolveEngine();
   return execa('bash', [engine, ...args], { stdio: 'inherit', reject: false });
-}
+}

package/src/lib/self.js

@@ -0,0 +1,94 @@
+import { execa } from 'execa';
+import pc from 'picocolors';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+
+export const NPM_NAME = pkg.name;
+export const BIN_NAME = 'theamify';
+
+/** Simple numeric semver compare: returns <0, 0, >0 when a is older/equal/newer. */
+export function compareVersions(a, b) {
+  const pa = String(a || '').split('.').map((n) => parseInt(n, 10) || 0);
+  const pb = String(b || '').split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+
+/** Query npm for the latest published version of this package. */
+export async function getLatestVersion() {
+  try {
+    const { stdout } = await execa('npm', ['view', NPM_NAME, 'version'], { reject: false });
+    const v = (stdout || '').trim();
+    return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check whether the running local version is behind the latest published one.
+ * @returns {Promise<{outdated:boolean, latest:string|null, current:string}>}
+ */
+export async function checkForUpdate() {
+  const latest = await getLatestVersion();
+  if (!latest) return { outdated: false, latest: null, current: pkg.version };
+  return { outdated: compareVersions(latest, pkg.version) > 0, latest, current: pkg.version };
+}
+
+/**
+ * If a newer version is available, offer to self-update via `npm install -g`.
+ * @returns {Promise<boolean>} true when an update was performed
+ */
+export async function promptSelfUpdate() {
+  const { outdated, latest, current } = await checkForUpdate();
+  if (!outdated || !latest) return false;
+
+  const p = await import('@clack/prompts');
+  const want = await p.confirm({
+    message: `A new version (${pc.cyan('v' + latest)}) is available — you have ${pc.dim('v' + current)}. Update now?`,
+    initialValue: true,
+  });
+  if (p.isCancel(want) || !want) {
+    p.log.message(pc.dim(`Keeping v${current} — update later with: npm install -g ${NPM_NAME}@latest`));
+    return false;
+  }
+
+  // Release the terminal so npm's output is visible & interruptible.
+  console.log();
+  const res = await execa('npm', ['install', '-g', `${NPM_NAME}@latest`], { stdio: 'inherit', reject: false });
+  if (res.exitCode !== 0) {
+    p.log.warn('Update failed. You can retry with: npm install -g ' + NPM_NAME + '@latest');
+    return false;
+  }
+  p.log.success(`Updated to v${latest}. Restart ${BIN_NAME} to use the new version.`);
+  return true;
+}
+
+/**
+ * Fully remove the npm package so the `theamify` command disappears from PATH.
+ * @returns {Promise<boolean>} true when uninstalled
+ */
+export async function selfUninstall() {
+  const p = await import('@clack/prompts');
+  const want = await p.confirm({
+    message: `Also remove the ${NPM_NAME} npm package, so the ${pc.cyan(BIN_NAME)} command is gone from your system?`,
+    initialValue: true,
+  });
+  if (p.isCancel(want) || !want) {
+    p.log.message(pc.dim(`Keeping the npm package — the ${BIN_NAME} command will remain.`));
+    return false;
+  }
+  console.log();
+  const res = await execa('npm', ['uninstall', '-g', NPM_NAME], { stdio: 'inherit', reject: false });
+  if (res.exitCode === 0) {
+    p.log.success(`${NPM_NAME} removed. The ${BIN_NAME} command is no longer available.`);
+    return true;
+  }
+  p.log.warn(`Could not uninstall ${NPM_NAME} automatically. Run: npm uninstall -g ${NPM_NAME}`);
+  return false;
+}

package/src/wizard/browse.js

@@ -91,17 +91,57 @@ async function ensureCached(engine, name) {
   }
 }
 
+/**
+ * Download every registry theme into the local cache during setup. Runs the
+ * engine's `get --all`, which skips anything already cached and never prompts
+ * per-theme. Returns the number cached afterwards.
+ */
+async function ensureAllThemes(engine, { prompt = true } = {}) {
+  if (prompt) {
+    const want = await p.confirm({
+      message: 'Download all themes now (so every theme has an instant preview)?',
+      initialValue: true,
+    });
+    if (p.isCancel(want) || !want) {
+      p.log.message(pc.dim('Skipped — you can download individual themes from the menu.'));
+      return;
+    }
+  }
+
+  const s = p.spinner();
+  s.start('Downloading all themes…');
+  try {
+    await execa('bash', [engine, 'get', '--all'], { stdio: 'inherit', reject: true });
+    s.stop(pc.green('All themes downloaded.'));
+  } catch (e) {
+    s.stop(pc.red(`Theme download incomplete: ${e.message}`));
+  }
+}
+
 /**
  * Interactive GRUB-theme browser wizard (mirrors GitSwitch's look & feel).
  * Stays in a menu loop: pick a theme → preview / download / apply / open →
  * back to the theme list — it NEVER hard-exits until you choose Quit.
  */
 export async function runThemeBrowser() {
+  // Step 0: self-check — offer an update if a newer version is published, and
+  // repair a broken/unprovisioned runtime before anything else.
+  const { checkForUpdate, promptSelfUpdate } = await import('../lib/self.js');
+  const { repairRuntime } = await import('../core/engine.js');
+  const { outdated } = await checkForUpdate();
+  if (outdated) await promptSelfUpdate();
+  await repairRuntime();
+
   // Step 1: ensure companion tools (chafa, grub-customizer) — detect, install
   // or update, then continue BEFORE showing the theme picker.
   await ensureManagedTools();
 
   const engine = await resolveEngine();
+
+  // Step 2: install-flow — make all themes downloadable/previewable up front so
+  // the user never has to fetch one just to see it.
+  await ensureAllThemes(engine, { prompt: true });
+
   let quit = false;
 
   while (!quit) {
@@ -140,7 +180,6 @@ export async function runThemeBrowser() {
       const action = await p.select({
         message: `What do you want to do with ${pc.cyan(picked.name)}?`,
         options: [
-          { value: 'preview', label: 'Preview terminal thumbnail', hint: cached ? 'renders below' : 'downloads first' },
           { value: 'get', label: 'Download / update it', hint: 'git clone into local cache' },
           { value: 'use', label: 'Apply to GRUB', hint: 'needs sudo; rebuilds GRUB' },
           { value: 'open', label: 'Open source page in browser' },
@@ -152,11 +191,7 @@ export async function runThemeBrowser() {
       if (p.isCancel(action) || action === 'quit') { quit = true; break; }
       if (action === 'menu') { backToMenu = true; break; }
 
-      if (action === 'preview') {
-        if (await ensureCached(engine, picked.name)) {
-          await showThemePreview({ name: picked.name, width: 80, height: 22 });
-        }
-      } else if (action === 'get') {
+      if (action === 'get') {
         await ensureCached(engine, picked.name);
       } else if (action === 'use') {
         await runUse(engine, picked.name);

package/vendor/theamify

@@ -10,7 +10,7 @@ set -euo pipefail
 # -----------------------------------------------------------------------------
 # VERSION & TOOL NAME
 # -----------------------------------------------------------------------------
-readonly VERSION="1.0.0"
+readonly VERSION="2.2.0"
 readonly TOOL="theamify"
 
 # -----------------------------------------------------------------------------