@coreify/quitx 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.2.0
+
+### Added
+
+- `--dry-run` simulation mode:
+  - Simulate quitting applications without sending termination signals or killing processes.
+  - Formatted preview output (`[dry-run] Would quit <app>` / `[dry-run] Would force quit <app>`).
+  - Supported across interactive selector, targeted app list, and `--all` flag.
+- Non-interactive configuration CLI:
+  - `quitx config show [--json]` to view current configuration as formatted list or JSON object.
+  - `quitx config get <key> [--json]` to retrieve individual configuration value.
+  - `quitx config set <key> <value> [--json]` with typed validation for booleans, force mode, and arrays.
+  - `quitx config reset [-y|--yes] [--json]` to restore default configuration non-interactively.
+- Automatic update toggle:
+  - Added `autoUpdate` configuration property (default `true`).
+  - Configurable via interactive menu and `quitx config set autoUpdate <bool>`.
+  - Automatic background 6-hour update checks honor this setting.
+- Package update checking system:
+  - Automatic 6-hour interval background check against npm registry (`CHECK_INTERVAL_MS`).
+  - Interactive manual update check command `quitx check-update` and `--check-update` flag with 60-second rate-limiting cooldown.
+  - `--no-update-check` flag to bypass update checks.
+  - Direct global package upgrade via `installUpdate` (`npm install --global @coreify/quitx@latest`).
+  - Persistent update cache in `~/.quitx/update.json` storing check timestamp and ignored versions.
+  - Full JSON output support for update queries (`quitx check-update --json`).
+
 ## 1.1.0
 
 ### Added

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { readFile } from 'fs/promises';
-import { select, isCancel, spinner, log, intro, multiselect, outro, confirm, cancel } from '@clack/prompts';
+import { spinner, select, isCancel, log, intro, outro, multiselect, confirm, cancel } from '@clack/prompts';
+import { readFile, mkdir, writeFile } from 'fs/promises';
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { execa } from 'execa';
 import { spawn } from 'child_process';
 
@@ -18,7 +18,8 @@ var DEFAULT_CONFIG = {
   groupBackground: true,
   defaultSelectAll: true,
   neverQuitMusic: false,
-  musicApps: []
+  musicApps: [],
+  autoUpdate: true
 };
 function loadConfig(filePath = CONFIG_FILE) {
   try {
@@ -34,6 +35,7 @@ function loadConfig(filePath = CONFIG_FILE) {
     const defaultSelectVal = typeof obj.defaultSelectAll === "boolean" ? obj.defaultSelectAll : obj.defaultSelect === "deselect-all" || obj.defaultSelection === "deselect-all" || obj.defaultSelect === false ? false : typeof obj.defaultSelect === "boolean" ? obj.defaultSelect : DEFAULT_CONFIG.defaultSelectAll;
     const groupBgVal = typeof obj.groupBackground === "boolean" ? obj.groupBackground : typeof obj.groupBackgroundInstances === "boolean" ? obj.groupBackgroundInstances : DEFAULT_CONFIG.groupBackground;
     const neverQuitMusicVal = typeof obj.neverQuitMusic === "boolean" ? obj.neverQuitMusic : DEFAULT_CONFIG.neverQuitMusic;
+    const autoUpdateVal = typeof obj.autoUpdate === "boolean" ? obj.autoUpdate : typeof obj.checkUpdate === "boolean" ? obj.checkUpdate : DEFAULT_CONFIG.autoUpdate;
     return {
       exclude: Array.isArray(obj.exclude) ? obj.exclude : [],
       force: obj.force === "force" || obj.force === "normal" ? obj.force : DEFAULT_CONFIG.force,
@@ -43,7 +45,8 @@ function loadConfig(filePath = CONFIG_FILE) {
       groupBackground: groupBgVal,
       defaultSelectAll: defaultSelectVal,
       neverQuitMusic: neverQuitMusicVal,
-      musicApps: Array.isArray(obj.musicApps) ? obj.musicApps : DEFAULT_CONFIG.musicApps
+      musicApps: Array.isArray(obj.musicApps) ? obj.musicApps : DEFAULT_CONFIG.musicApps,
+      autoUpdate: autoUpdateVal
     };
   } catch {
     return { ...DEFAULT_CONFIG, exclude: [], musicApps: [] };
@@ -652,6 +655,13 @@ async function quitApps(apps, options = {}, executor, deferredScheduler = defaul
   if (apps.length === 0) {
     return [];
   }
+  if (options.dryRun) {
+    return apps.map((app) => ({
+      app,
+      success: true,
+      forced: options.force ?? false
+    }));
+  }
   const currentTerminalApps = [];
   const otherApps = [];
   for (const app of apps) {
@@ -731,14 +741,15 @@ function showOutro(message) {
 function showCancel(message = "Cancelled.") {
   cancel(message);
 }
-function renderResults(results) {
+function renderResults(results, dryRun = false) {
   for (const res of results) {
     if (res.success) {
-      const label = res.forced ? `Force quit ${res.app.name}` : res.app.name;
+      const label = dryRun ? res.forced ? `[dry-run] Would force quit ${res.app.name}` : `[dry-run] Would quit ${res.app.name}` : res.forced ? `Force quit ${res.app.name}` : res.app.name;
       log.success(label);
     } else {
+      const prefix = dryRun ? "[dry-run] " : "";
       const reason = res.error ? ` (${res.error})` : "";
-      log.error(`Could not quit ${res.app.name}${reason}`);
+      log.error(`${prefix}Could not quit ${res.app.name}${reason}`);
     }
   }
 }
@@ -764,28 +775,37 @@ OPTIONS:
   -y, --yes               Skip confirmation prompts
   -l, --list              List running GUI apps and exit
   -f, --force             Force quit apps (SIGKILL) if normal quit fails
+      --dry-run           Simulate quitting without terminating apps
   -b, --background        Include background processes in app list
       --include-finder    Include Finder in the app list
       --include-trash     Include Trash in the app list (empties on quit)
       --exclude <apps>    Add apps to persistent exclude list (comma-separated)
+      --check-update      Check for package updates (60s rate limit)
+      --no-update-check   Disable automatic update check for this run
       --config            Open interactive config manager
       --json              Output data in JSON format
   -h, --help              Show help information
   -v, --version           Show version number
 
 COMMANDS:
-  config                  Manage configuration interactively
+  config [action]         Manage configuration (show, get, set, reset)
   exclude                 Manage excluded applications interactively
+  check-update            Check for package updates
 
 EXAMPLES:
   $ quitx                         Interactive app selector
   $ quitx --all                   Quit all running apps (with confirmation)
+  $ quitx --all --dry-run         Preview quitting all apps without killing them
   $ quitx --all --yes             Quit all running apps immediately
   $ quitx --list                  List currently running GUI apps
   $ quitx --list --background     List all apps including background processes
   $ quitx --list --include-finder List apps including Finder
   $ quitx config                  Open interactive config manager
+  $ quitx config show             Print current configuration
+  $ quitx config set force true   Set default quit mode to force
+  $ quitx config get exclude      Print excluded apps list
   $ quitx exclude                 Open interactive menu to manage excluded apps
+  $ quitx check-update            Check for package updates
   $ quitx --exclude Spotify,Slack Add Spotify and Slack to exclude list
   $ quitx Slack,Discord           Quit specific apps directly
 `.trim()
@@ -909,14 +929,20 @@ async function allCommand(options = {}) {
   }
   const s = spinner();
   if (!options.json) {
-    s.start(`Quitting ${apps.length} apps...`);
+    s.start(
+      options.dryRun ? `Simulating quit for ${apps.length} apps...` : `Quitting ${apps.length} apps...`
+    );
   }
-  const results = await quitApps(apps, { force: useForce });
+  const results = await quitApps(apps, {
+    force: useForce,
+    dryRun: options.dryRun
+  });
   if (!options.json) {
-    s.stop("Quitting complete");
-    renderResults(results);
+    s.stop(options.dryRun ? "Dry run complete" : "Quitting complete");
+    renderResults(results, options.dryRun);
     const successCount = results.filter((r) => r.success).length;
-    showOutro(`Quit ${successCount} of ${apps.length} apps.`);
+    const actionVerb = options.dryRun ? "Would quit" : "Quit";
+    showOutro(`${actionVerb} ${successCount} of ${apps.length} apps.`);
     printThanks(options);
   } else {
     console.log(
@@ -1119,6 +1145,32 @@ async function toggleNeverQuitMusic() {
     `Never quit music apps: ${config.neverQuitMusic ? "enabled" : "disabled"}`
   );
 }
+async function toggleAutoUpdate() {
+  const config = loadConfig();
+  const choice = await select({
+    message: `Automatic Update Checks (current: ${config.autoUpdate ? "enabled" : "disabled"})`,
+    options: [
+      {
+        value: "enabled",
+        label: "Enabled",
+        hint: "Check npm registry in background every 6 hours for updates."
+      },
+      {
+        value: "disabled",
+        label: "Disabled",
+        hint: "Never perform automatic background update checks."
+      },
+      backOption()
+    ],
+    initialValue: config.autoUpdate ? "enabled" : "disabled"
+  });
+  if (isCancel(choice) || choice === BACK_VALUE) return;
+  config.autoUpdate = choice === "enabled";
+  saveConfig(config);
+  log.success(
+    `Automatic update checks: ${config.autoUpdate ? "enabled" : "disabled"}`
+  );
+}
 async function manageExcludedApps() {
   const choice = await select({
     message: "Manage excluded apps",
@@ -1305,6 +1357,11 @@ async function configCommand() {
           label: "Never quit music apps",
           hint: `current: ${config.neverQuitMusic ? "enabled" : "disabled"}`
         },
+        {
+          value: "auto-update",
+          label: "Automatic update checks",
+          hint: `current: ${config.autoUpdate ? "enabled" : "disabled"}`
+        },
         {
           value: "default-select",
           label: "Deselect apps by default",
@@ -1346,6 +1403,7 @@ async function configCommand() {
     if (choice === "background") await toggleIncludeBackground();
     if (choice === "group-background") await toggleGroupBackground();
     if (choice === "never-quit-music") await toggleNeverQuitMusic();
+    if (choice === "auto-update") await toggleAutoUpdate();
     if (choice === "default-select") await toggleDefaultSelection();
     if (choice === "finder") await toggleIncludeFinder();
     if (choice === "trash") await toggleIncludeTrash();
@@ -1357,6 +1415,140 @@ async function configCommand() {
   printThanks();
   return 0;
 }
+var VALID_CONFIG_KEYS = [
+  "exclude",
+  "force",
+  "includeFinder",
+  "includeTrash",
+  "includeBackground",
+  "groupBackground",
+  "defaultSelectAll",
+  "neverQuitMusic",
+  "musicApps",
+  "autoUpdate"
+];
+async function handleConfigCli(options = {}) {
+  const action = options.configAction;
+  if (!action) {
+    return await configCommand();
+  }
+  const config = loadConfig();
+  if (action === "show") {
+    if (options.json) {
+      console.log(JSON.stringify(config, null, 2));
+      return 0;
+    }
+    console.log("quitx configuration:");
+    for (const [key, value] of Object.entries(config)) {
+      const displayVal = Array.isArray(value) ? value.length === 0 ? "[]" : `[${value.join(", ")}]` : String(value);
+      console.log(`  ${key}: ${displayVal}`);
+    }
+    return 0;
+  }
+  if (action === "get") {
+    if (!options.configKey) {
+      console.error("\u2716 Missing config key. Usage: quitx config get <key>");
+      return 1;
+    }
+    const key = options.configKey;
+    if (!VALID_CONFIG_KEYS.includes(key)) {
+      console.error(
+        `\u2716 Unknown config key: "${options.configKey}". Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`
+      );
+      return 1;
+    }
+    const val = config[key];
+    if (options.json) {
+      console.log(JSON.stringify({ [key]: val }, null, 2));
+    } else if (Array.isArray(val)) {
+      console.log(val.join(", "));
+    } else {
+      console.log(String(val));
+    }
+    return 0;
+  }
+  if (action === "set") {
+    if (!options.configKey) {
+      console.error(
+        "\u2716 Missing config key. Usage: quitx config set <key> <value>"
+      );
+      return 1;
+    }
+    if (options.configValue === void 0) {
+      console.error(
+        `\u2716 Missing value for "${options.configKey}". Usage: quitx config set <key> <value>`
+      );
+      return 1;
+    }
+    const key = options.configKey;
+    if (!VALID_CONFIG_KEYS.includes(key)) {
+      console.error(
+        `\u2716 Unknown config key: "${options.configKey}". Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`
+      );
+      return 1;
+    }
+    const raw = options.configValue.trim();
+    if (key === "force") {
+      const lower = raw.toLowerCase();
+      if (lower === "force" || lower === "true" || lower === "1") {
+        config.force = "force";
+      } else if (lower === "normal" || lower === "false" || lower === "0") {
+        config.force = "normal";
+      } else {
+        console.error(
+          `\u2716 Invalid value for force: "${raw}". Must be "normal" or "force".`
+        );
+        return 1;
+      }
+    } else if (key === "includeFinder" || key === "includeTrash" || key === "includeBackground" || key === "groupBackground" || key === "defaultSelectAll" || key === "neverQuitMusic" || key === "autoUpdate") {
+      const lower = raw.toLowerCase();
+      if (["true", "1", "yes", "on", "enable", "enabled"].includes(lower)) {
+        config[key] = true;
+      } else if (["false", "0", "no", "off", "disable", "disabled"].includes(lower)) {
+        config[key] = false;
+      } else {
+        console.error(
+          `\u2716 Invalid boolean for ${key}: "${raw}". Use true or false.`
+        );
+        return 1;
+      }
+    } else if (key === "exclude" || key === "musicApps") {
+      const items = raw.split(",").map((s) => s.trim()).filter(Boolean);
+      config[key] = items;
+    }
+    saveConfig(config);
+    if (options.json) {
+      console.log(JSON.stringify({ [key]: config[key] }, null, 2));
+    } else {
+      const displayVal = Array.isArray(config[key]) ? `[${config[key].join(", ")}]` : String(config[key]);
+      console.log(`Set ${key} = ${displayVal}`);
+    }
+    return 0;
+  }
+  if (action === "reset") {
+    if (!options.yes) {
+      const confirm2 = await select({
+        message: "Reset all settings to defaults?",
+        options: [
+          { value: "yes", label: "Yes, reset all" },
+          { value: "no", label: "No, keep current settings" }
+        ],
+        initialValue: "no"
+      });
+      if (isCancel(confirm2) || confirm2 !== "yes") {
+        return 0;
+      }
+    }
+    saveConfig({ ...DEFAULT_CONFIG, exclude: [], musicApps: [] });
+    if (options.json) {
+      console.log(JSON.stringify({ reset: true }, null, 2));
+    } else {
+      log.success("Config reset to defaults.");
+    }
+    return 0;
+  }
+  return 0;
+}
 async function manageExcludeInteractive() {
   showIntro();
   const choice = await select({
@@ -1554,15 +1746,21 @@ async function interactiveCommand(options = {}) {
   }
   if (!options.json) {
     s.start(
-      `Quitting ${targetApps.length} ${targetApps.length === 1 ? "app" : "apps"}...`
+      options.dryRun ? `Simulating quit for ${targetApps.length} ${targetApps.length === 1 ? "app" : "apps"}...` : `Quitting ${targetApps.length} ${targetApps.length === 1 ? "app" : "apps"}...`
     );
   }
-  const results = await quitApps(targetApps, { force: useForce });
+  const results = await quitApps(targetApps, {
+    force: useForce,
+    dryRun: options.dryRun
+  });
   if (!options.json) {
-    s.stop("Quitting complete");
-    renderResults(results);
+    s.stop(options.dryRun ? "Dry run complete" : "Quitting complete");
+    renderResults(results, options.dryRun);
     const successCount = results.filter((r) => r.success).length;
-    showOutro(`Done. Quit ${successCount} of ${targetApps.length} apps.`);
+    const actionVerb = options.dryRun ? "Would quit" : "Quit";
+    showOutro(
+      `Done. ${actionVerb} ${successCount} of ${targetApps.length} apps.`
+    );
     printThanks(options);
   } else {
     console.log(
@@ -1599,6 +1797,199 @@ async function listCommand(options = {}) {
   renderList(apps, options.json);
   return 0;
 }
+var CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var MANUAL_RATE_LIMIT_MS = 60 * 1e3;
+var REQUEST_TIMEOUT_MS = 1500;
+var REGISTRY_URL = "https://registry.npmjs.org/@coreify%2Fquitx/latest";
+var FALLBACK_REGISTRY_URL = "https://registry.npmjs.org/quitx/latest";
+var RELEASE_URL = "https://github.com/coreify/quitx/releases/latest";
+function updateCacheDirectory() {
+  const configured = process.env.XDG_CACHE_HOME;
+  if (configured) return join(configured, "quitx");
+  return join(homedir(), ".quitx");
+}
+function parseVersion(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([\dA-Za-z.-]+))?(?:\+[\dA-Za-z.-]+)?$/u.exec(
+    version.trim()
+  );
+  if (!match) return void 0;
+  const numbers = [
+    Number(match[1]),
+    Number(match[2]),
+    Number(match[3])
+  ];
+  return match[4] ? { numbers, prerelease: match[4].split(".") } : { numbers };
+}
+function compareVersions(left, right) {
+  const leftVersion = parseVersion(left);
+  const rightVersion = parseVersion(right);
+  if (!leftVersion || !rightVersion) return 0;
+  for (let index = 0; index < 3; index++) {
+    const difference = leftVersion.numbers[index] - rightVersion.numbers[index];
+    if (difference !== 0) return Math.sign(difference);
+  }
+  if (!leftVersion.prerelease && !rightVersion.prerelease) return 0;
+  if (!leftVersion.prerelease) return 1;
+  if (!rightVersion.prerelease) return -1;
+  const length = Math.max(
+    leftVersion.prerelease.length,
+    rightVersion.prerelease.length
+  );
+  for (let index = 0; index < length; index++) {
+    const leftPart = leftVersion.prerelease[index];
+    const rightPart = rightVersion.prerelease[index];
+    if (leftPart === void 0) return -1;
+    if (rightPart === void 0) return 1;
+    if (leftPart === rightPart) continue;
+    const leftNumber = /^\d+$/u.test(leftPart) ? Number(leftPart) : void 0;
+    const rightNumber = /^\d+$/u.test(rightPart) ? Number(rightPart) : void 0;
+    if (leftNumber !== void 0 && rightNumber !== void 0) {
+      return Math.sign(leftNumber - rightNumber);
+    }
+    if (leftNumber !== void 0) return -1;
+    if (rightNumber !== void 0) return 1;
+    return leftPart.localeCompare(rightPart);
+  }
+  return 0;
+}
+async function readCache(path) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (typeof value !== "object" || value === null) return {};
+    const record = value;
+    return {
+      ...typeof record.checkedAt === "number" && Number.isFinite(record.checkedAt) ? { checkedAt: record.checkedAt } : {},
+      ...typeof record.ignoredVersion === "string" && parseVersion(record.ignoredVersion) ? { ignoredVersion: record.ignoredVersion } : {},
+      ...typeof record.latestVersion === "string" && parseVersion(record.latestVersion) ? { latestVersion: record.latestVersion } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+async function writeCache(path, value) {
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(value), { mode: 384 });
+  } catch {
+  }
+}
+async function fetchLatestVersion(fetcher = fetch) {
+  const urls = [REGISTRY_URL, FALLBACK_REGISTRY_URL];
+  for (const url of urls) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    timer.unref();
+    try {
+      const response = await fetcher(url, {
+        headers: { accept: "application/json" },
+        signal: controller.signal
+      });
+      if (!response.ok) continue;
+      const value = await response.json();
+      if (typeof value === "object" && value !== null && "version" in value && typeof value.version === "string" && parseVersion(value.version)) {
+        return value.version;
+      }
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw new Error("Unable to fetch latest version from npm registry");
+}
+async function checkForUpdate(currentVersion, options = {}) {
+  if (!parseVersion(currentVersion)) return void 0;
+  const now = options.now ?? Date.now();
+  const cachePath = join(
+    options.cacheDirectory ?? updateCacheDirectory(),
+    "update.json"
+  );
+  const cache = await readCache(cachePath);
+  let latestVersion = cache.latestVersion;
+  if (options.force || !cache.checkedAt || now - cache.checkedAt >= CHECK_INTERVAL_MS) {
+    try {
+      latestVersion = await fetchLatestVersion(options.fetcher ?? fetch);
+      await writeCache(cachePath, {
+        ...cache,
+        checkedAt: now,
+        latestVersion
+      });
+    } catch {
+    }
+  }
+  if (!latestVersion || latestVersion === cache.ignoredVersion || compareVersions(latestVersion, currentVersion) <= 0) {
+    return void 0;
+  }
+  return {
+    currentVersion,
+    latestVersion,
+    releaseUrl: RELEASE_URL
+  };
+}
+async function checkUpdateManually(currentVersion, options = {}) {
+  const now = options.now ?? Date.now();
+  const cachePath = join(
+    options.cacheDirectory ?? updateCacheDirectory(),
+    "update.json"
+  );
+  const cache = await readCache(cachePath);
+  let latestVersion = cache.latestVersion;
+  const isRateLimited = Boolean(
+    !options.force && cache.checkedAt && now - cache.checkedAt < MANUAL_RATE_LIMIT_MS
+  );
+  if (!isRateLimited) {
+    try {
+      latestVersion = await fetchLatestVersion(options.fetcher ?? fetch);
+      await writeCache(cachePath, {
+        ...cache,
+        checkedAt: now,
+        latestVersion
+      });
+    } catch {
+    }
+  }
+  const effectiveLatest = latestVersion ?? currentVersion;
+  const updateAvailable = Boolean(
+    latestVersion && compareVersions(latestVersion, currentVersion) > 0
+  );
+  return {
+    currentVersion,
+    latestVersion: effectiveLatest,
+    rateLimited: isRateLimited,
+    releaseUrl: RELEASE_URL,
+    updateAvailable
+  };
+}
+async function ignoreUpdateVersion(version, cacheDir = updateCacheDirectory()) {
+  const cachePath = join(cacheDir, "update.json");
+  const cache = await readCache(cachePath);
+  await writeCache(cachePath, { ...cache, ignoredVersion: version });
+}
+function installUpdate(version, spawner = spawn) {
+  if (!parseVersion(version)) {
+    return Promise.reject(new Error(`Invalid update version: ${version}`));
+  }
+  return new Promise((resolve, reject) => {
+    const pkg = `@coreify/quitx@${version}`;
+    const child = spawner("npm", ["install", "--global", pkg], {
+      stdio: "inherit",
+      windowsHide: true
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (code === 0) resolve();
+      else {
+        reject(
+          new Error(
+            signal ? `Update stopped by ${signal}` : `npm install exited with code ${code ?? "unknown"}`
+          )
+        );
+      }
+    });
+  });
+}
+function updateNotice(update) {
+  return `Update available: ${update.currentVersion} \u2192 ${update.latestVersion}. Run: npm install --global @coreify/quitx@latest`;
+}
 
 // src/utils/platform.ts
 function isMacOS(platform = process.platform) {
@@ -1636,10 +2027,42 @@ function parseCliArgs(args) {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (!arg) continue;
-    if (arg === "config") {
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else if (arg === "config") {
       options.manageConfig = true;
+      const next = args[i + 1];
+      if (next && !next.startsWith("-") && ["show", "get", "set", "reset"].includes(next.toLowerCase())) {
+        options.configAction = next.toLowerCase();
+        i++;
+        if (options.configAction === "get") {
+          const key = args[++i];
+          if (key && !key.startsWith("-")) {
+            options.configKey = key;
+          } else if (key) {
+            i--;
+          }
+        } else if (options.configAction === "set") {
+          const key = args[++i];
+          if (key && !key.startsWith("-")) {
+            options.configKey = key;
+            const val = args[++i];
+            if (val && !val.startsWith("-")) {
+              options.configValue = val;
+            } else if (val) {
+              i--;
+            }
+          } else if (key) {
+            i--;
+          }
+        }
+      }
     } else if (arg === "exclude") {
       options.manageExclude = true;
+    } else if (arg === "check-update" || arg === "--check-update") {
+      options.checkUpdate = true;
+    } else if (arg === "--no-update-check") {
+      options.noUpdateCheck = true;
     } else if (arg === "-a" || arg === "--all") {
       options.all = true;
     } else if (arg === "-y" || arg === "--yes") {
@@ -1683,7 +2106,13 @@ function parseCliArgs(args) {
     }
   }
   if (rawPositional.length > 0) {
-    if (options.manageExclude) {
+    if (options.manageConfig) {
+      if (!options.configAction) {
+        throw new Error(
+          `Unknown config command: "${rawPositional[0]}". Usage: quitx config [show|get|set|reset]`
+        );
+      }
+    } else if (options.manageExclude) {
       if (rawPositional.length > 1 && !rawPositional.some((a) => a.includes(","))) {
         throw new Error(
           "Multiple exclude applications must be comma-separated, not space-separated. Example: quitx exclude Spotify,Discord"
@@ -1715,6 +2144,130 @@ function parseCliArgs(args) {
   }
   return options;
 }
+async function handleManualUpdateCheck(version, options) {
+  const isInteractive = !options.json && Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  if (options.json) {
+    const result2 = await checkUpdateManually(version, { force: options.force });
+    console.log(JSON.stringify(result2, null, 2));
+    return 0;
+  }
+  if (isInteractive) {
+    showIntro();
+    const checkSpinner = spinner();
+    checkSpinner.start("Checking npm registry for updates");
+    const result2 = await checkUpdateManually(version, { force: options.force });
+    if (result2.rateLimited) {
+      checkSpinner.stop(
+        `Checked recently (rate limited, 60s cooldown). Latest: v${result2.latestVersion}`
+      );
+    } else if (result2.updateAvailable) {
+      checkSpinner.stop(
+        `Update available: ${result2.currentVersion} \u2192 ${result2.latestVersion}`
+      );
+    } else {
+      checkSpinner.stop(`quitx is up to date (v${result2.currentVersion})`);
+    }
+    if (result2.updateAvailable) {
+      console.log(
+        "\n  Upgrade Available: Run npm install --global @coreify/quitx@latest\n"
+      );
+      const answer = await select({
+        message: `Install v${result2.latestVersion} now?`,
+        options: [
+          { value: "install", label: "Install update now" },
+          { value: "skip", label: "Skip for now" }
+        ],
+        initialValue: "install"
+      });
+      if (isCancel(answer) || answer === "skip") {
+        printThanks(options);
+        return 0;
+      }
+      if (answer === "install") {
+        console.log(`Updating to ${result2.latestVersion}...`);
+        try {
+          await installUpdate(result2.latestVersion);
+          showOutro(
+            `Updated to ${result2.latestVersion}. Restart quitx to use it.`
+          );
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`Failed to install update: ${msg}`);
+        }
+      }
+    }
+    printThanks(options);
+    return 0;
+  }
+  const result = await checkUpdateManually(version, { force: options.force });
+  if (result.updateAvailable) {
+    console.log(
+      `Update available: ${result.currentVersion} \u2192 ${result.latestVersion}`
+    );
+    console.log("Run: npm install --global @coreify/quitx@latest");
+  } else {
+    console.log(`quitx is up to date (${result.currentVersion})`);
+  }
+  if (result.rateLimited) {
+    console.log(
+      "(Checked recently with 60s rate limit; use --force to bypass)"
+    );
+  }
+  printThanks(options);
+  return 0;
+}
+async function handleAutoUpdateCheck(currentVersion, options) {
+  if (options.noUpdateCheck || options.checkUpdate || options.help || options.version || options.dryRun) {
+    return;
+  }
+  const config = loadConfig();
+  if (config.autoUpdate === false) {
+    return;
+  }
+  try {
+    const update = await checkForUpdate(currentVersion);
+    if (!update) return;
+    if (options.json || options.yes || !process.stdin.isTTY || !process.stdout.isTTY) {
+      console.error(updateNotice(update));
+      return;
+    }
+    console.log(
+      `
+Update available \xB7 ${update.currentVersion} \u2192 ${update.latestVersion}
+Release notes: ${update.releaseUrl}`
+    );
+    const action = await select({
+      message: "Update quitx?",
+      options: [
+        { value: "update", label: "Update now", hint: "npm install --global" },
+        { value: "skip", label: "Skip" },
+        {
+          value: "ignore",
+          label: "Skip this version",
+          hint: `hide ${update.latestVersion}`
+        }
+      ],
+      initialValue: "update"
+    });
+    if (isCancel(action) || action === "skip") {
+      return;
+    }
+    if (action === "ignore") {
+      await ignoreUpdateVersion(update.latestVersion);
+      return;
+    }
+    console.log(`Updating to ${update.latestVersion}...`);
+    try {
+      await installUpdate(update.latestVersion);
+      showOutro(`Updated to ${update.latestVersion}. Restart quitx to use it.`);
+      process.exit(0);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to install update: ${msg}`);
+    }
+  } catch {
+  }
+}
 async function main(argv = process.argv.slice(2)) {
   if (!isMacOS()) {
     console.error(
@@ -1742,15 +2295,21 @@ async function main(argv = process.argv.slice(2)) {
     printThanks(options);
     return 0;
   }
+  const version = await getPackageVersion();
   if (options.version) {
-    const version = await getPackageVersion();
     renderVersion(version);
     printThanks(options);
     return 0;
   }
+  if (options.checkUpdate) {
+    return await handleManualUpdateCheck(version, options);
+  }
+  if (!options.noUpdateCheck && !options.json) {
+    await handleAutoUpdateCheck(version, options);
+  }
   try {
     if (options.manageConfig) {
-      return await configCommand();
+      return await handleConfigCli(options);
     }
     if (options.manageExclude || options.exclude && options.exclude.length > 0) {
       return await excludeCommand(options);
@@ -1784,4 +2343,4 @@ if (isMain) {
   });
 }
 
-export { getPackageVersion, main, parseCliArgs };
+export { getPackageVersion, handleAutoUpdateCheck, handleManualUpdateCheck, main, parseCliArgs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coreify/quitx",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A macOS CLI for viewing running GUI applications and quitting them properly.",
   "type": "module",
   "bin": {
@@ -35,7 +35,7 @@
   "scripts": {
     "build": "tsup",
     "build:watch": "tsup --watch",
-    "check": "npm run format:check && npm run lint && npm run typecheck && npm run test:coverage && npm run build",
+    "check": "npm run format && npm run format:check && npm run lint && npm run typecheck && npm run test:coverage && npm run build",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint .",