wanas-zcrm-extractor 1.6.2 → 1.7.0

package/README.md

@@ -424,6 +424,8 @@ Errors are reported in a single, consistent format: **expected** problems (e.g.
 
 Every command also writes a timestamped **debug log** to `~/.zcrm/logs/` (e.g. `pull-<timestamp>.log`, `audit-<timestamp>.log`) capturing all activity for that run — including the quiet "skipped" lines and the **full API error bodies** that aren't printed to the console. When a command fails, its log path is shown in the output. `zcrm pull` additionally writes a copy into its output folder at `<output>/.zcrm/.logs/`.
 
+The CLI also checks npm for a newer version **once a day in the background** (never blocking your command) and shows a one-line update notice when one is available. To disable it, set `NO_UPDATE_NOTIFIER=1` (or `ZCRM_NO_UPDATE_CHECK=1`); it is skipped automatically in CI.
+
 ---
 
 ## ✉️ Support & Feedback

package/bin/cli.js

@@ -40,6 +40,12 @@ let debugLogPath = null;
   }
 })();
 
+// Non-blocking check for a newer published version (reads a cached result and
+// refreshes it in a detached background process). The notice is shown on exit.
+const { checkForUpdates, renderUpdateNotice } = require('../src/utils/updateNotifier');
+let updateInfo = null;
+try { updateInfo = checkForUpdates(require('../package.json')); } catch (e) { updateInfo = null; }
+
 const { CliError, reportError } = require('../src/utils/errorReporter');
 
 let errorReported = false;
@@ -69,6 +75,8 @@ process.on('exit', (code) => {
   if (code && !errorReported && debugLogPath) {
     try { process.stderr.write(`\x1b[90mℹ Debug log: ${debugLogPath}\x1b[0m\n`); } catch (e) { /* ignore */ }
   }
+  // Show the "update available" notice last, after the command's own output.
+  try { renderUpdateNotice(updateInfo); } catch (e) { /* ignore */ }
 });
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wanas-zcrm-extractor",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "Local Zoho CRM V8 Metadata Extractor CLI and Web Dashboard Utility",
   "main": "server.js",
   "bin": {

package/src/utils/updateCheckWorker.js

@@ -0,0 +1,43 @@
+/**
+ * Detached background worker: fetches the latest published version of the
+ * package from the npm registry and writes it to ~/.zcrm/update-check.json.
+ * Spawned by updateNotifier so the check never blocks (or slows) a CLI command.
+ * It is silent and never throws — any failure just leaves the cache unchanged.
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+
+const pkgName = process.argv[2];
+if (!pkgName) process.exit(0);
+
+const CACHE_FILE = path.join(os.homedir(), '.zcrm', 'update-check.json');
+
+function done() { try { process.exit(0); } catch (e) { /* ignore */ } }
+
+try {
+  const req = https.get(
+    `https://registry.npmjs.org/${encodeURIComponent(pkgName)}/latest`,
+    { timeout: 8000, headers: { Accept: 'application/json' } },
+    (res) => {
+      if (res.statusCode !== 200) { res.resume(); return done(); }
+      let body = '';
+      res.on('data', (c) => { body += c; if (body.length > 1e6) req.destroy(); });
+      res.on('end', () => {
+        try {
+          const latest = JSON.parse(body).version;
+          if (latest) {
+            fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+            fs.writeFileSync(CACHE_FILE, JSON.stringify({ latest, checkedAt: Date.now() }));
+          }
+        } catch (e) { /* ignore parse/write errors */ }
+        done();
+      });
+    }
+  );
+  req.on('error', done);
+  req.on('timeout', () => { try { req.destroy(); } catch (e) {} done(); });
+} catch (e) {
+  done();
+}

package/src/utils/updateNotifier.js

@@ -0,0 +1,112 @@
+/**
+ * Lightweight, non-blocking "a new version is available" notifier.
+ *
+ * On each run it reads a small cache (~/.zcrm/update-check.json). If the cache
+ * already knows of a newer published version, `checkForUpdates` returns the info
+ * so the CLI can show a notice. When the cache is stale (older than a day) it
+ * spawns a detached background worker to refresh it for next time — so the
+ * registry lookup never blocks or slows down the command.
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+const CACHE_FILE = path.join(os.homedir(), '.zcrm', 'update-check.json');
+const WORKER = path.join(__dirname, 'updateCheckWorker.js');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // at most once per day
+
+function readCache() {
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8')) || {};
+  } catch (e) {
+    return {};
+  }
+}
+
+/**
+ * Compares two `X.Y.Z` version strings. Returns true if `a` is newer than `b`.
+ * Pre-release/build suffixes are ignored (we only notify on stable bumps).
+ */
+function isNewer(a, b) {
+  const parse = (v) => String(v).split('-')[0].split('.').map((n) => parseInt(n, 10) || 0);
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return true;
+    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+  }
+  return false;
+}
+
+function scheduleBackgroundCheck(pkgName) {
+  try {
+    const child = spawn(process.execPath, [WORKER, pkgName], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true
+    });
+    child.unref();
+  } catch (e) {
+    // never let the update check break the CLI
+  }
+}
+
+/**
+ * @param {{name:string, version:string}} pkg
+ * @returns {{name:string, current:string, latest:string}|null} update info, or null.
+ */
+function checkForUpdates(pkg) {
+  // Respect common opt-outs and skip in CI / non-interactive shells.
+  if (
+    process.env.NO_UPDATE_NOTIFIER ||
+    process.env.ZCRM_NO_UPDATE_CHECK ||
+    process.env.CI
+  ) {
+    return null;
+  }
+
+  let info = null;
+  try {
+    const cache = readCache();
+    const fresh = cache.checkedAt && (Date.now() - cache.checkedAt) < CHECK_INTERVAL_MS;
+    if (!fresh) {
+      scheduleBackgroundCheck(pkg.name);
+    }
+    if (cache.latest && isNewer(cache.latest, pkg.version)) {
+      info = { name: pkg.name, current: pkg.version, latest: cache.latest };
+    }
+  } catch (e) {
+    return null;
+  }
+  return info;
+}
+
+/**
+ * Renders the update notice to stderr. Only a left border is drawn so the
+ * variable-width content (with ANSI colors) never needs right-edge alignment.
+ * @param {{name:string, current:string, latest:string}|null} info
+ */
+function renderUpdateNotice(info) {
+  if (!info) return;
+  const y = '\x1b[33m';
+  const dim = '\x1b[2m';
+  const green = '\x1b[1;32m';
+  const cyan = '\x1b[36m';
+  const reset = '\x1b[0m';
+  const lines = [
+    '',
+    `${y}╭──────────────────────────────────────────────╮${reset}`,
+    `${y}│${reset}  📦 Update available  ${dim}${info.current}${reset} → ${green}${info.latest}${reset}`,
+    `${y}│${reset}  Run  ${cyan}npm i -g ${info.name}${reset}  to update.`,
+    `${y}╰──────────────────────────────────────────────╯${reset}`,
+    ''
+  ];
+  try {
+    process.stderr.write(lines.join('\n') + '\n');
+  } catch (e) {
+    // ignore
+  }
+}
+
+module.exports = { checkForUpdates, renderUpdateNotice, isNewer };