@coreify/quitx 1.0.0

package/dist/cli.js

@@ -0,0 +1,1366 @@
+#!/usr/bin/env node
+import { readFile } from 'fs/promises';
+import { select, isCancel, spinner, log, intro, multiselect, outro, confirm, cancel } from '@clack/prompts';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { execa } from 'execa';
+import { spawn } from 'child_process';
+import { MultiSelectPrompt } from '@clack/core';
+
+var CONFIG_DIR = join(homedir(), ".quitx");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  exclude: [],
+  force: "normal",
+  includeFinder: false,
+  includeBackground: false
+};
+function loadConfig(filePath = CONFIG_FILE) {
+  try {
+    if (!existsSync(filePath)) {
+      return { ...DEFAULT_CONFIG, exclude: [] };
+    }
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) {
+      return { ...DEFAULT_CONFIG, exclude: [] };
+    }
+    const obj = parsed;
+    return {
+      exclude: Array.isArray(obj.exclude) ? obj.exclude : [],
+      force: obj.force === "force" || obj.force === "normal" ? obj.force : DEFAULT_CONFIG.force,
+      includeFinder: typeof obj.includeFinder === "boolean" ? obj.includeFinder : DEFAULT_CONFIG.includeFinder,
+      includeBackground: typeof obj.includeBackground === "boolean" ? obj.includeBackground : DEFAULT_CONFIG.includeBackground
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG, exclude: [] };
+  }
+}
+function saveConfig(config, filePath = CONFIG_FILE) {
+  try {
+    const dir = join(filePath, "..");
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(filePath, JSON.stringify(config, null, 2), "utf-8");
+  } catch {
+  }
+}
+function addExcludedApps(apps, filePath = CONFIG_FILE) {
+  const current = loadConfig(filePath);
+  const set = new Set(current.exclude.map((a) => a.toLowerCase().trim()));
+  const updated = [...current.exclude];
+  for (const app of apps) {
+    const trimmed = app.trim();
+    if (trimmed && !set.has(trimmed.toLowerCase())) {
+      set.add(trimmed.toLowerCase());
+      updated.push(trimmed);
+    }
+  }
+  const next = { ...current, exclude: updated };
+  saveConfig(next, filePath);
+  return next;
+}
+function removeExcludedApps(apps, filePath = CONFIG_FILE) {
+  const current = loadConfig(filePath);
+  const toRemove = new Set(apps.map((a) => a.toLowerCase().trim()));
+  const updated = current.exclude.filter(
+    (app) => !toRemove.has(app.toLowerCase().trim())
+  );
+  const next = { ...current, exclude: updated };
+  saveConfig(next, filePath);
+  return next;
+}
+
+// src/macos/jxa.ts
+var APPKIT_PREAMBLE = "ObjC.import('AppKit');";
+var RUNNING_APPS = "$.NSWorkspace.sharedWorkspace.runningApplications";
+function buildAppMatcherScript(body) {
+  const bodyIndented = body.trim().split("\n").map((line) => `    ${line}`).join("\n");
+  return `${APPKIT_PREAMBLE}
+function run(argv) {
+  const apps = ${RUNNING_APPS};
+  for (let i = 0; i < apps.count; i++) {
+    const app = apps.objectAtIndex(i);
+${bodyIndented}
+  }
+  return 'false';
+}`;
+}
+async function runJXA(script, args = [], executor = execa) {
+  const { stdout } = await executor("osascript", [
+    "-l",
+    "JavaScript",
+    "-e",
+    script,
+    ...args
+  ]);
+  return stdout.trim();
+}
+
+// src/macos/apps.ts
+function buildDiscoveryScript(includeBackground = false) {
+  const bg = includeBackground ? "true" : "false";
+  return `${APPKIT_PREAMBLE}
+function run() {
+  const includeBackground = ${bg};
+  const Regular = $.NSApplicationActivationPolicyRegular;
+  const apps = ${RUNNING_APPS};
+  const lines = [];
+  for (let i = 0; i < apps.count; i++) {
+    const app = apps.objectAtIndex(i);
+    if (!includeBackground && app.activationPolicy !== Regular) continue;
+    const name = app.localizedName ? app.localizedName.js : '';
+    const bundleId = app.bundleIdentifier ? app.bundleIdentifier.js : '';
+    const pid = String(app.processIdentifier);
+    lines.push(name + '\\t' + bundleId + '\\t' + pid);
+  }
+  return lines.join('\\n');
+}`.trim();
+}
+var IS_APP_RUNNING_SCRIPT = buildAppMatcherScript(`
+const name = argv[0] || '';
+const bundleId = argv[1] || '';
+if (bundleId && app.bundleIdentifier && app.bundleIdentifier.js === bundleId) {
+  return 'true';
+}
+if (name && app.localizedName && app.localizedName.js === name) {
+  return 'true';
+}
+`);
+function formatDynamicName(identifier) {
+  const parts = identifier.split(".").filter(Boolean);
+  const last = parts[parts.length - 1];
+  if (!last || last.length <= 1) {
+    return identifier;
+  }
+  const spaced = last.replace(/[-_]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2");
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+function parseAppListOutput(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return [];
+  }
+  if (trimmed.includes("	") || trimmed.includes("\n")) {
+    const lines = trimmed.split("\n").map((l) => l.trim()).filter(Boolean);
+    const results = [];
+    for (const line of lines) {
+      const parts = line.split("	");
+      const rawName = parts[0]?.trim();
+      if (!rawName) continue;
+      const rawBundle = parts[1]?.trim();
+      const bundleId = rawBundle && rawBundle !== "missing value" && rawBundle.length > 0 ? rawBundle : void 0;
+      const rawPid = parts[2]?.trim();
+      const pidNum = rawPid ? parseInt(rawPid, 10) : void 0;
+      const pid = !Number.isNaN(pidNum) && pidNum !== void 0 && pidNum > 0 ? pidNum : void 0;
+      let name = rawName;
+      if (bundleId && rawName === bundleId) {
+        name = formatDynamicName(bundleId);
+      }
+      results.push({ name, bundleId, pid });
+    }
+    return results;
+  }
+  return trimmed.split(",").map((name) => name.trim()).filter(Boolean).map((name) => ({ name }));
+}
+function sortApps(apps) {
+  return [...apps].sort(
+    (a, b) => a.name.localeCompare(b.name, void 0, { sensitivity: "base" })
+  );
+}
+function filterApps(apps, optionsOrExclude = {}) {
+  const opts = Array.isArray(optionsOrExclude) ? { exclude: optionsOrExclude } : optionsOrExclude;
+  const exclude = opts.exclude ?? [];
+  const includeFinder = opts.includeFinder ?? false;
+  const seen = /* @__PURE__ */ new Set();
+  const excludeSet = new Set(exclude.map((e) => e.toLowerCase().trim()));
+  const filtered = [];
+  for (const app of apps) {
+    const nameLower = app.name.toLowerCase().trim();
+    const bundleLower = app.bundleId?.toLowerCase().trim();
+    if (nameLower === "quitx" || bundleLower === "com.kiron.quitx") {
+      continue;
+    }
+    if (!includeFinder) {
+      if (nameLower === "finder" || bundleLower === "com.apple.finder") {
+        continue;
+      }
+    }
+    if (excludeSet.has(nameLower) || bundleLower && excludeSet.has(bundleLower)) {
+      continue;
+    }
+    const key = bundleLower ?? nameLower;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    filtered.push(app);
+  }
+  return sortApps(filtered);
+}
+async function getRunningApps(optionsOrExclude, executor) {
+  let exec;
+  let filterOpts = {};
+  let includeBackground = false;
+  if (typeof optionsOrExclude === "function") {
+    exec = optionsOrExclude;
+  } else if (Array.isArray(optionsOrExclude)) {
+    filterOpts = { exclude: optionsOrExclude };
+    exec = executor;
+  } else if (optionsOrExclude && typeof optionsOrExclude === "object") {
+    const opts = optionsOrExclude;
+    filterOpts = {
+      exclude: opts.exclude ?? [],
+      includeFinder: opts.includeFinder ?? false
+    };
+    includeBackground = opts.includeBackground ?? false;
+    exec = executor;
+  } else {
+    exec = executor;
+  }
+  const script = buildDiscoveryScript(includeBackground);
+  const stdout = await runJXA(script, [], exec);
+  const apps = parseAppListOutput(stdout);
+  return filterApps(apps, filterOpts);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && ("code" in error && error.code === "EPERM" || "message" in error && error.message.includes("EPERM"))) {
+      return true;
+    }
+    return false;
+  }
+}
+async function isAppRunning(target, executor) {
+  if (typeof target === "number") {
+    return isProcessAlive(target);
+  }
+  if (typeof target === "object" && target.pid !== void 0 && target.pid > 0) {
+    return isProcessAlive(target.pid);
+  }
+  const name = typeof target === "string" ? target : target.name;
+  const bundleId = typeof target === "object" ? target.bundleId ?? "" : "";
+  try {
+    const res = await runJXA(IS_APP_RUNNING_SCRIPT, [name, bundleId], executor);
+    return res.trim().toLowerCase() === "true";
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/macos/terminal.ts
+var KNOWN_TERMINALS = [
+  {
+    name: "Terminal",
+    aliases: ["apple_terminal", "terminal"],
+    bundleIds: ["com.apple.terminal"]
+  },
+  {
+    name: "iTerm2",
+    aliases: ["iterm.app", "iterm", "iterm2"],
+    bundleIds: ["com.googlecode.iterm2"]
+  },
+  {
+    name: "Warp",
+    aliases: ["warpterminal", "warp"],
+    bundleIds: ["dev.warp.warp-stable", "dev.warp.warp"]
+  },
+  {
+    name: "Ghostty",
+    aliases: ["ghostty"],
+    bundleIds: ["com.mitchellh.ghostty"]
+  },
+  {
+    name: "Alacritty",
+    aliases: ["alacritty"],
+    bundleIds: ["org.alacritty"]
+  },
+  {
+    name: "kitty",
+    aliases: ["kitty"],
+    bundleIds: ["net.kovidgoyal.kitty"]
+  },
+  {
+    name: "WezTerm",
+    aliases: ["wezterm", "wezterm-gui"],
+    bundleIds: ["com.github.wez.wezterm"]
+  },
+  {
+    name: "Hyper",
+    aliases: ["hyper"],
+    bundleIds: ["co.zeit.hyper"]
+  },
+  {
+    name: "Visual Studio Code",
+    aliases: ["vscode", "code"],
+    bundleIds: ["com.microsoft.vscode", "com.microsoft.vscodeinsiders"]
+  },
+  {
+    name: "Cursor",
+    aliases: ["cursor"],
+    bundleIds: ["com.todesktop.230313mzl4w4u92"]
+  }
+];
+function getCurrentTerminalApp(env = process.env) {
+  const termProgram = env["TERM_PROGRAM"]?.toLowerCase().trim();
+  const terminalEmulator = env["TERMINAL_EMULATOR"]?.toLowerCase().trim();
+  const lcTerminal = env["LC_TERMINAL"]?.toLowerCase().trim();
+  const target = termProgram || terminalEmulator || lcTerminal;
+  if (!target) {
+    return null;
+  }
+  if (target.includes("warp")) {
+    return "Warp";
+  }
+  for (const term of KNOWN_TERMINALS) {
+    if (term.aliases.some(
+      (alias) => target === alias || alias !== "terminal" && target.includes(alias)
+    )) {
+      return term.name;
+    }
+  }
+  return env["TERM_PROGRAM"] || null;
+}
+function isCurrentTerminalApp(app, env = process.env) {
+  const current = getCurrentTerminalApp(env);
+  if (!current) {
+    return false;
+  }
+  const curLower = current.toLowerCase();
+  const appNameLower = app.name.toLowerCase();
+  const appBundleLower = app.bundleId?.toLowerCase();
+  if (appNameLower === curLower) {
+    return true;
+  }
+  for (const term of KNOWN_TERMINALS) {
+    if (term.name.toLowerCase() === curLower) {
+      if (appNameLower === term.name.toLowerCase() || appBundleLower && term.bundleIds.includes(appBundleLower)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/macos/quit.ts
+var QUIT_JXA_SCRIPT = buildAppMatcherScript(`
+const bundleId = argv[0] || '';
+const name = argv[1] || '';
+const bid = app.bundleIdentifier ? app.bundleIdentifier.js : '';
+const nm = app.localizedName ? app.localizedName.js : '';
+if ((bundleId && bid === bundleId) || (name && nm === name)) {
+  return String(app.terminate());
+}
+`);
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function defaultDeferredQuitScheduler(app, force = false) {
+  try {
+    const bundleId = app.bundleId ?? "";
+    const cmd = force && app.pid ? `sleep 0.4 && kill -9 ${app.pid}` : `sleep 0.4 && osascript -l JavaScript -e ${shellQuote(QUIT_JXA_SCRIPT)} ${shellQuote(bundleId)} ${shellQuote(app.name)}`;
+    const child = spawn("sh", ["-c", cmd], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function sendQuitSignal(app, executor) {
+  const res = await runJXA(
+    QUIT_JXA_SCRIPT,
+    [app.bundleId ?? "", app.name],
+    executor
+  );
+  if (res.trim().toLowerCase() !== "true") {
+    throw new Error(`Could not quit "${app.name}"`);
+  }
+}
+function forceQuitApp(app) {
+  if (app.pid && app.pid > 0) {
+    try {
+      process.kill(app.pid, "SIGKILL");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+async function quitApps(apps, options = {}, executor, deferredScheduler = defaultDeferredQuitScheduler) {
+  if (apps.length === 0) {
+    return [];
+  }
+  const currentTerminalApps = [];
+  const otherApps = [];
+  for (const app of apps) {
+    if (isCurrentTerminalApp(app)) {
+      currentTerminalApps.push(app);
+    } else {
+      otherApps.push(app);
+    }
+  }
+  const results = [];
+  if (otherApps.length > 0) {
+    const timeoutMs = options.timeoutMs ?? 700;
+    await Promise.allSettled(
+      otherApps.map((app) => sendQuitSignal(app, executor))
+    );
+    await sleep(timeoutMs);
+    for (const app of otherApps) {
+      const stillRunning = await isAppRunning(app, executor);
+      if (!stillRunning) {
+        results.push({ app, success: true, forced: false });
+        continue;
+      }
+      if (options.force) {
+        const killed = forceQuitApp(app);
+        if (killed) {
+          await sleep(100);
+          const aliveAfterForce = await isAppRunning(app, executor);
+          if (!aliveAfterForce) {
+            results.push({ app, success: true, forced: true });
+            continue;
+          }
+        }
+        results.push({
+          app,
+          success: false,
+          forced: true,
+          error: "App remained running after force quit"
+        });
+        continue;
+      }
+      results.push({
+        app,
+        success: false,
+        forced: false,
+        error: "App is still running (may have unsaved changes or prompt)"
+      });
+    }
+  }
+  for (const termApp of currentTerminalApps) {
+    deferredScheduler(termApp, options.force ?? false);
+    results.push({
+      app: termApp,
+      success: true,
+      forced: options.force ?? false
+    });
+  }
+  return results;
+}
+function showIntro() {
+  intro("quitx");
+}
+function showOutro(message) {
+  outro(message);
+}
+function showCancel(message = "Cancelled.") {
+  cancel(message);
+}
+function renderResults(results) {
+  for (const res of results) {
+    if (res.success) {
+      const label = res.forced ? `Force quit ${res.app.name}` : res.app.name;
+      log.success(label);
+    } else {
+      const reason = res.error ? ` (${res.error})` : "";
+      log.error(`Could not quit ${res.app.name}${reason}`);
+    }
+  }
+}
+function renderList(apps, json = false) {
+  if (json) {
+    console.log(JSON.stringify(apps, null, 2));
+    return;
+  }
+  for (const app of apps) {
+    console.log(app.name);
+  }
+}
+function renderHelp() {
+  console.log(
+    `
+quitx - Quit running macOS apps from your terminal.
+
+USAGE:
+  $ quitx [options] [apps]
+
+OPTIONS:
+  -a, --all               Quit all running GUI apps
+  -y, --yes               Skip confirmation prompts
+  -l, --list              List running GUI apps and exit
+  -f, --force             Force quit apps (SIGKILL) if normal quit fails
+  -b, --background        Include background processes in app list
+      --include-finder    Include Finder in the app list
+      --exclude <apps>    Add apps to persistent exclude list (comma-separated)
+      --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
+  exclude                 Manage excluded applications interactively
+
+EXAMPLES:
+  $ quitx                         Interactive app selector
+  $ quitx --all                   Quit all running apps (with confirmation)
+  $ 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 exclude                 Open interactive menu to manage excluded apps
+  $ quitx --exclude Spotify,Slack Add Spotify and Slack to exclude list
+  $ quitx Slack,Discord           Quit specific apps directly
+`.trim()
+  );
+}
+function renderVersion(version) {
+  console.log(`quitx v${version}`);
+}
+var THANKS_MESSAGE = "\nThanks for using quitx..!";
+function printThanks(options) {
+  if (options?.json || options?.quiet) return;
+  console.log(THANKS_MESSAGE);
+}
+var SELECT_ALL_VALUE = "__QUIT_ALL_APPS__";
+var BACK_VALUE = "back";
+function backOption() {
+  return { value: BACK_VALUE, label: "Back to main menu" };
+}
+function handleQuitAllToggle(currentValue, selectedValues) {
+  if (currentValue === SELECT_ALL_VALUE) {
+    if (selectedValues.includes(SELECT_ALL_VALUE)) {
+      return [];
+    }
+    return [SELECT_ALL_VALUE];
+  }
+  if (selectedValues.includes(SELECT_ALL_VALUE)) {
+    return [...selectedValues];
+  }
+  const isSelected = selectedValues.includes(currentValue);
+  return isSelected ? selectedValues.filter((v) => v !== currentValue) : [...selectedValues, currentValue];
+}
+function attachQuitAllBehavior(prompt) {
+  let _cursor = prompt.cursor ?? 0;
+  let _value = prompt.value ? [...prompt.value] : [];
+  Object.defineProperty(prompt, "cursor", {
+    get() {
+      return _cursor;
+    },
+    set(val) {
+      if (_value.includes(SELECT_ALL_VALUE)) {
+        _cursor = 0;
+      } else {
+        _cursor = val;
+      }
+    },
+    configurable: true
+  });
+  Object.defineProperty(prompt, "value", {
+    get() {
+      return _value;
+    },
+    set(val) {
+      if (!Array.isArray(val)) {
+        _value = [];
+        return;
+      }
+      if (val.includes(SELECT_ALL_VALUE)) {
+        _value = [SELECT_ALL_VALUE];
+        _cursor = 0;
+      } else {
+        _value = val.filter((v) => v !== SELECT_ALL_VALUE);
+      }
+    },
+    configurable: true
+  });
+  prompt.toggleValue = function() {
+    const cur = prompt.options[prompt.cursor ?? 0]?.value;
+    if (!cur) return;
+    prompt.value = handleQuitAllToggle(cur, prompt.value ?? []);
+  };
+  prompt.toggleAll = function() {
+    if (prompt.value?.includes(SELECT_ALL_VALUE)) {
+      prompt.value = [];
+    } else {
+      prompt.value = [SELECT_ALL_VALUE];
+    }
+  };
+  prompt.toggleInvert = function() {
+    if (prompt.value?.includes(SELECT_ALL_VALUE)) {
+      prompt.value = [];
+    } else {
+      prompt.value = [SELECT_ALL_VALUE];
+    }
+  };
+}
+async function selectApps(apps) {
+  if (apps.length === 0) {
+    return [];
+  }
+  const appOptions = apps.map((app) => {
+    const hint = app.bundleId ?? (app.pid ? `PID: ${app.pid}` : void 0);
+    return {
+      value: app.bundleId ?? `${app.name}-${app.pid ?? 0}`,
+      label: app.name,
+      ...hint ? { hint } : {}
+    };
+  });
+  const options = [
+    {
+      value: SELECT_ALL_VALUE,
+      label: "Quit all apps",
+      hint: `${apps.length} eligible apps`
+    },
+    ...appOptions
+  ];
+  const initialValues = [SELECT_ALL_VALUE];
+  const proto = MultiSelectPrompt?.prototype;
+  const origPrompt = proto?.prompt;
+  const origToggleValue = proto?.toggleValue;
+  const origToggleAll = proto?.toggleAll;
+  const origToggleInvert = proto?.toggleInvert;
+  let selected;
+  try {
+    if (proto && origPrompt) {
+      proto.prompt = function() {
+        if (this.options?.some((o) => o.value === SELECT_ALL_VALUE)) {
+          attachQuitAllBehavior(
+            this
+          );
+        }
+        return origPrompt.call(this);
+      };
+    }
+    selected = await multiselect({
+      message: "Select apps to quit",
+      options,
+      required: false,
+      initialValues
+    });
+  } finally {
+    if (proto && origPrompt) proto.prompt = origPrompt;
+    if (proto && origToggleValue) proto.toggleValue = origToggleValue;
+    if (proto && origToggleAll) proto.toggleAll = origToggleAll;
+    if (proto && origToggleInvert) {
+      proto.toggleInvert = origToggleInvert;
+    }
+  }
+  if (isCancel(selected) || !Array.isArray(selected)) {
+    return selected;
+  }
+  const selectedArray = selected;
+  if (selectedArray.length === 0) {
+    return [];
+  }
+  if (selectedArray.includes(SELECT_ALL_VALUE)) {
+    return [...apps];
+  }
+  const selectedSet = new Set(selectedArray);
+  return apps.filter((app) => {
+    const key = app.bundleId ?? `${app.name}-${app.pid ?? 0}`;
+    return selectedSet.has(key);
+  });
+}
+async function shouldConfirmQuit(count, isAll = false, forceYes = false) {
+  if (forceYes || count === 0) {
+    return true;
+  }
+  if (!isAll && count < 4) {
+    return true;
+  }
+  const message = isAll ? `Quit all ${count} apps?` : `Quit ${count} selected apps?`;
+  const confirmed = await confirm({
+    message,
+    initialValue: false
+  });
+  return confirmed;
+}
+
+// src/commands/all.ts
+async function allCommand(options = {}) {
+  if (!options.json) {
+    showIntro();
+  }
+  const config = loadConfig();
+  const useForce = options.force ?? config.force === "force";
+  const includeFinder = options.includeFinder ?? config.includeFinder;
+  const includeBackground = options.includeBackground ?? config.includeBackground;
+  const apps = await getRunningApps({
+    exclude: config.exclude,
+    includeFinder,
+    includeBackground
+  });
+  if (apps.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ quit: 0, results: [] }, null, 2));
+    } else {
+      showOutro("No running apps found to quit.");
+      printThanks(options);
+    }
+    return 0;
+  }
+  if (!options.yes) {
+    const confirmation = await shouldConfirmQuit(apps.length, true, false);
+    if (isCancel(confirmation) || confirmation !== true) {
+      showCancel("Cancelled.");
+      printThanks(options);
+      return 0;
+    }
+  }
+  const s = spinner();
+  if (!options.json) {
+    s.start(`Quitting ${apps.length} apps...`);
+  }
+  const results = await quitApps(apps, { force: useForce });
+  if (!options.json) {
+    s.stop("Quitting complete");
+    renderResults(results);
+    const successCount = results.filter((r) => r.success).length;
+    showOutro(`Quit ${successCount} of ${apps.length} apps.`);
+    printThanks(options);
+  } else {
+    console.log(
+      JSON.stringify(
+        {
+          total: apps.length,
+          quit: results.filter((r) => r.success).length,
+          results
+        },
+        null,
+        2
+      )
+    );
+  }
+  return 0;
+}
+async function toggleQuitMode() {
+  const config = loadConfig();
+  const choice = await select({
+    message: `Quit Mode (current: ${config.force})`,
+    options: [
+      {
+        value: "normal",
+        label: "Normal Quit",
+        hint: "Sends a graceful quit signal. Apps may prompt to save unsaved work before closing."
+      },
+      {
+        value: "force",
+        label: "Force Quit",
+        hint: "Immediately kills processes (SIGKILL). Unsaved work will be lost. Use when apps are unresponsive."
+      },
+      backOption()
+    ],
+    initialValue: config.force
+  });
+  if (isCancel(choice) || choice === BACK_VALUE) return;
+  config.force = choice;
+  saveConfig(config);
+  log.success(`Quit mode set to: ${config.force}`);
+}
+async function toggleIncludeFinder() {
+  const config = loadConfig();
+  const choice = await select({
+    message: `Include Finder (current: ${config.includeFinder ? "enabled" : "disabled"})`,
+    options: [
+      {
+        value: "disabled",
+        label: "Disabled",
+        hint: "Finder is excluded from the quit list. Recommended \u2014 Finder restarts automatically and quitting it rarely helps."
+      },
+      {
+        value: "enabled",
+        label: "Enabled",
+        hint: "Finder appears in the quit list like any other app. Useful if you want to fully restart Finder."
+      },
+      backOption()
+    ],
+    initialValue: config.includeFinder ? "enabled" : "disabled"
+  });
+  if (isCancel(choice) || choice === BACK_VALUE) return;
+  config.includeFinder = choice === "enabled";
+  saveConfig(config);
+  log.success(
+    `Include Finder: ${config.includeFinder ? "enabled" : "disabled"}`
+  );
+}
+async function toggleIncludeBackground() {
+  const config = loadConfig();
+  const choice = await select({
+    message: `Background Apps (current: ${config.includeBackground ? "enabled" : "disabled"})`,
+    options: [
+      {
+        value: "disabled",
+        label: "Disabled",
+        hint: "Only shows foreground GUI apps. This is the default and safest option \u2014 system daemons stay hidden."
+      },
+      {
+        value: "enabled",
+        label: "Enabled",
+        hint: "Shows ALL application processes including background agents and helpers. Use with caution \u2014 quitting system processes can cause instability."
+      },
+      backOption()
+    ],
+    initialValue: config.includeBackground ? "enabled" : "disabled"
+  });
+  if (isCancel(choice) || choice === BACK_VALUE) return;
+  config.includeBackground = choice === "enabled";
+  saveConfig(config);
+  log.success(
+    `Background apps: ${config.includeBackground ? "enabled" : "disabled"}`
+  );
+}
+async function manageExcludedApps() {
+  const choice = await select({
+    message: "Manage excluded apps",
+    options: [
+      { value: "add", label: "Add running apps to exclude list" },
+      { value: "remove", label: "Remove apps from exclude list" },
+      { value: "view", label: "View current exclude list" },
+      backOption()
+    ]
+  });
+  if (isCancel(choice) || choice === BACK_VALUE) return;
+  const config = loadConfig();
+  if (choice === "view") {
+    if (config.exclude.length === 0) {
+      log.info("No apps currently excluded.");
+    } else {
+      log.info(
+        `Excluded apps:
+${config.exclude.map((e) => `  - ${e}`).join("\n")}`
+      );
+    }
+    return;
+  }
+  if (choice === "add") {
+    const apps = await getRunningApps();
+    const currentSet = new Set(
+      config.exclude.map((e) => e.toLowerCase().trim())
+    );
+    const available = apps.filter(
+      (a) => !currentSet.has(a.name.toLowerCase().trim()) && !(a.bundleId && currentSet.has(a.bundleId.toLowerCase().trim()))
+    );
+    if (available.length === 0) {
+      log.info("All running apps are already excluded.");
+      return;
+    }
+    const selected = await multiselect({
+      message: "Select apps to exclude from quitting",
+      options: available.map((a) => ({
+        value: a.name,
+        label: a.name,
+        ...a.bundleId ? { hint: a.bundleId } : {}
+      })),
+      required: false
+    });
+    if (isCancel(selected)) return;
+    if (!Array.isArray(selected) || selected.length === 0) {
+      log.info("No apps selected.");
+      return;
+    }
+    addExcludedApps(selected);
+    log.success(`Added ${selected.length} apps to exclude list.`);
+    return;
+  }
+  if (choice === "remove") {
+    if (config.exclude.length === 0) {
+      log.info("No apps currently in exclude list.");
+      return;
+    }
+    const selected = await multiselect({
+      message: "Select apps to remove from exclude list",
+      options: config.exclude.map((name) => ({
+        value: name,
+        label: name
+      })),
+      required: false
+    });
+    if (isCancel(selected)) return;
+    if (!Array.isArray(selected) || selected.length === 0) {
+      log.info("No apps selected.");
+      return;
+    }
+    removeExcludedApps(selected);
+    log.success(`Removed ${selected.length} apps from exclude list.`);
+  }
+}
+function resetConfig() {
+  saveConfig({ ...DEFAULT_CONFIG, exclude: [] });
+  log.success("Config reset to defaults.");
+}
+async function configCommand() {
+  showIntro();
+  let running = true;
+  while (running) {
+    const config = loadConfig();
+    const choice = await select({
+      message: "Configuration",
+      options: [
+        {
+          value: "quit-mode",
+          label: `Toggle Quit Mode`,
+          hint: `current: ${config.force}`
+        },
+        {
+          value: "finder",
+          label: `Toggle Include Finder`,
+          hint: `current: ${config.includeFinder ? "enabled" : "disabled"}`
+        },
+        {
+          value: "background",
+          label: `Toggle Background Apps`,
+          hint: `current: ${config.includeBackground ? "enabled" : "disabled"}`
+        },
+        {
+          value: "exclude",
+          label: "Manage Excluded Apps",
+          hint: `${config.exclude.length} excluded`
+        },
+        {
+          value: "reset",
+          label: "Reset to Defaults",
+          hint: "restore all settings"
+        },
+        { value: "exit", label: "Exit" }
+      ]
+    });
+    if (isCancel(choice) || choice === "exit") {
+      running = false;
+      continue;
+    }
+    if (choice === "quit-mode") await toggleQuitMode();
+    if (choice === "finder") await toggleIncludeFinder();
+    if (choice === "background") await toggleIncludeBackground();
+    if (choice === "exclude") await manageExcludedApps();
+    if (choice === "reset") resetConfig();
+  }
+  showOutro("Config saved.");
+  printThanks();
+  return 0;
+}
+async function manageExcludeInteractive() {
+  showIntro();
+  const choice = await select({
+    message: "Manage excluded apps",
+    options: [
+      { value: "add", label: "Add running apps to exclude list" },
+      { value: "remove", label: "Remove apps from exclude list" },
+      { value: "view", label: "View current exclude list" }
+    ]
+  });
+  if (isCancel(choice)) {
+    showCancel("Cancelled.");
+    printThanks();
+    return 0;
+  }
+  const currentConfig = loadConfig();
+  if (choice === "view") {
+    if (currentConfig.exclude.length === 0) {
+      showOutro("No apps currently excluded in config.json.");
+    } else {
+      showOutro(
+        `Excluded apps:
+${currentConfig.exclude.map((e) => `  - ${e}`).join("\n")}`
+      );
+    }
+    printThanks();
+    return 0;
+  }
+  if (choice === "add") {
+    const apps = await getRunningApps();
+    const currentSet = new Set(
+      currentConfig.exclude.map((e) => e.toLowerCase().trim())
+    );
+    const available = apps.filter(
+      (a) => !currentSet.has(a.name.toLowerCase().trim()) && !(a.bundleId && currentSet.has(a.bundleId.toLowerCase().trim()))
+    );
+    if (available.length === 0) {
+      showOutro("All running apps are already excluded.");
+      printThanks();
+      return 0;
+    }
+    const selected = await multiselect({
+      message: "Select apps to exclude from quitting",
+      options: available.map((a) => ({
+        value: a.name,
+        label: a.name,
+        ...a.bundleId ? { hint: a.bundleId } : {}
+      })),
+      required: false
+    });
+    if (isCancel(selected)) {
+      showCancel("Cancelled.");
+      printThanks();
+      return 0;
+    }
+    if (!Array.isArray(selected) || selected.length === 0) {
+      showOutro("No apps selected.");
+      printThanks();
+      return 0;
+    }
+    addExcludedApps(selected);
+    showOutro(`Added ${selected.length} apps to exclude list.`);
+    printThanks();
+    return 0;
+  }
+  if (choice === "remove") {
+    if (currentConfig.exclude.length === 0) {
+      showOutro("No apps currently in exclude list.");
+      printThanks();
+      return 0;
+    }
+    const selected = await multiselect({
+      message: "Select apps to remove from exclude list",
+      options: currentConfig.exclude.map((name) => ({
+        value: name,
+        label: name
+      })),
+      required: false
+    });
+    if (isCancel(selected)) {
+      showCancel("Cancelled.");
+      printThanks();
+      return 0;
+    }
+    if (!Array.isArray(selected) || selected.length === 0) {
+      showOutro("No apps selected.");
+      printThanks();
+      return 0;
+    }
+    removeExcludedApps(selected);
+    showOutro(`Removed ${selected.length} apps from exclude list.`);
+    printThanks();
+    return 0;
+  }
+  return 0;
+}
+async function excludeCommand(options = {}) {
+  if (options.exclude && options.exclude.length > 0) {
+    const updated = addExcludedApps(options.exclude);
+    if (options.json) {
+      console.log(JSON.stringify(updated, null, 2));
+    } else {
+      showIntro();
+      showOutro(
+        `Added to exclude list:
+${options.exclude.map((e) => `  - ${e}`).join("\n")}`
+      );
+      printThanks(options);
+    }
+    return 0;
+  }
+  return await manageExcludeInteractive();
+}
+async function interactiveCommand(options = {}) {
+  if (!options.json) {
+    showIntro();
+  }
+  const s = spinner();
+  if (!options.json) {
+    s.start("Scanning running applications...");
+  }
+  const config = loadConfig();
+  const useForce = options.force ?? config.force === "force";
+  const includeFinder = options.includeFinder ?? config.includeFinder;
+  const includeBackground = options.includeBackground ?? config.includeBackground;
+  const apps = await getRunningApps({
+    exclude: config.exclude,
+    includeFinder,
+    includeBackground
+  });
+  if (!options.json) {
+    s.stop(
+      `Found ${apps.length} running ${apps.length === 1 ? "app" : "apps"}`
+    );
+  }
+  if (apps.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ quit: 0, results: [] }, null, 2));
+    } else {
+      showOutro("No running GUI applications found to quit.");
+      printThanks(options);
+    }
+    return 0;
+  }
+  let targetApps;
+  if (options.apps && options.apps.length > 0) {
+    const targets = new Set(options.apps.map((a) => a.toLowerCase().trim()));
+    targetApps = apps.filter(
+      (app) => targets.has(app.name.toLowerCase().trim()) || app.bundleId && targets.has(app.bundleId.toLowerCase().trim())
+    );
+    if (targetApps.length === 0) {
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            { quit: 0, results: [], error: "No matching apps running" },
+            null,
+            2
+          )
+        );
+      } else {
+        log.warn("None of the specified applications are currently running.");
+        showOutro("Nothing to quit.");
+        printThanks(options);
+      }
+      return 0;
+    }
+  } else {
+    const selected = await selectApps(apps);
+    if (typeof selected === "symbol" || isCancel(selected)) {
+      showCancel("Cancelled.");
+      printThanks(options);
+      return 0;
+    }
+    if (selected.length === 0) {
+      showOutro("No apps selected.");
+      printThanks(options);
+      return 0;
+    }
+    targetApps = selected;
+  }
+  if (!options.yes) {
+    const confirmation = await shouldConfirmQuit(
+      targetApps.length,
+      targetApps.length === apps.length,
+      false
+    );
+    if (isCancel(confirmation) || confirmation !== true) {
+      showCancel("Cancelled.");
+      printThanks(options);
+      return 0;
+    }
+  }
+  if (!options.json) {
+    s.start(
+      `Quitting ${targetApps.length} ${targetApps.length === 1 ? "app" : "apps"}...`
+    );
+  }
+  const results = await quitApps(targetApps, { force: useForce });
+  if (!options.json) {
+    s.stop("Quitting complete");
+    renderResults(results);
+    const successCount = results.filter((r) => r.success).length;
+    showOutro(`Done. Quit ${successCount} of ${targetApps.length} apps.`);
+    printThanks(options);
+  } else {
+    console.log(
+      JSON.stringify(
+        {
+          total: targetApps.length,
+          quit: results.filter((r) => r.success).length,
+          results
+        },
+        null,
+        2
+      )
+    );
+  }
+  return 0;
+}
+
+// src/commands/list.ts
+async function listCommand(options = {}) {
+  const config = loadConfig();
+  const includeFinder = options.includeFinder ?? config.includeFinder;
+  const includeBackground = options.includeBackground ?? config.includeBackground;
+  const apps = await getRunningApps({
+    exclude: config.exclude,
+    includeFinder,
+    includeBackground
+  });
+  renderList(apps, options.json);
+  return 0;
+}
+
+// src/utils/platform.ts
+function isMacOS(platform = process.platform) {
+  return platform === "darwin";
+}
+function ensureMacOS(platform = process.platform) {
+  if (!isMacOS(platform)) {
+    throw new Error("quitx only works on macOS.");
+  }
+}
+
+// src/cli.ts
+async function getPackageVersion() {
+  for (const url of [
+    new URL("../package.json", import.meta.url),
+    new URL("../../package.json", import.meta.url)
+  ]) {
+    try {
+      const content = await readFile(url, "utf-8");
+      const parsed = JSON.parse(content);
+      if (typeof parsed === "object" && parsed !== null && "version" in parsed && typeof parsed.version === "string") {
+        return parsed.version;
+      }
+    } catch {
+    }
+  }
+  return "unknown";
+}
+function parseCliArgs(args) {
+  const options = {
+    apps: [],
+    exclude: []
+  };
+  const rawPositional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (arg === "config") {
+      options.manageConfig = true;
+    } else if (arg === "exclude") {
+      options.manageExclude = true;
+    } else if (arg === "-a" || arg === "--all") {
+      options.all = true;
+    } else if (arg === "-y" || arg === "--yes") {
+      options.yes = true;
+    } else if (arg === "-l" || arg === "--list") {
+      options.list = true;
+    } else if (arg === "-f" || arg === "--force") {
+      options.force = true;
+    } else if (arg === "-h" || arg === "--help") {
+      options.help = true;
+    } else if (arg === "-v" || arg === "--version") {
+      options.version = true;
+    } else if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--include-finder") {
+      options.includeFinder = true;
+    } else if (arg === "-b" || arg === "--background") {
+      options.includeBackground = true;
+    } else if (arg === "--config") {
+      options.manageConfig = true;
+    } else if (arg === "--exclude") {
+      const next = args[++i];
+      if (next) {
+        const split = next.split(",").map((s) => s.trim()).filter(Boolean);
+        options.exclude?.push(...split);
+      }
+    } else if (arg.startsWith("--exclude=")) {
+      const val = arg.slice("--exclude=".length);
+      if (val) {
+        const split = val.split(",").map((s) => s.trim()).filter(Boolean);
+        options.exclude?.push(...split);
+      }
+    } else if (arg.startsWith("-")) {
+      continue;
+    } else {
+      rawPositional.push(arg);
+    }
+  }
+  if (rawPositional.length > 0) {
+    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"
+        );
+      }
+      const combined = rawPositional.join(" ");
+      const split = combined.split(",").map((s) => s.trim()).filter(Boolean);
+      if (split.length === 0) {
+        throw new Error(
+          "No application name specified to exclude. Example: quitx exclude Spotify,Discord"
+        );
+      }
+      options.exclude?.push(...split);
+    } else {
+      if (rawPositional.length > 1 && !rawPositional.some((a) => a.includes(","))) {
+        throw new Error(
+          'Multiple applications must be comma-separated, not space-separated. Example: quitx Slack,Discord. For names with spaces, use quotes: quitx "Google Chrome"'
+        );
+      }
+      const combined = rawPositional.join(" ");
+      const split = combined.split(",").map((s) => s.trim()).filter(Boolean);
+      if (split.length === 0) {
+        throw new Error(
+          'No application name specified. Example: quitx Slack,Discord. For names with spaces, use quotes: quitx "Google Chrome"'
+        );
+      }
+      options.apps?.push(...split);
+    }
+  }
+  return options;
+}
+async function main(argv = process.argv.slice(2)) {
+  if (!isMacOS()) {
+    console.error("\u2716 quitx only works on macOS.");
+    return 1;
+  }
+  ensureMacOS();
+  let options = {};
+  try {
+    options = parseCliArgs(argv);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(`\u2716 Error: ${msg}`);
+    return 1;
+  }
+  if (process.stdin.isTTY) {
+    process.once("SIGINT", () => {
+      printThanks(options);
+      process.exit(130);
+    });
+  }
+  if (options.help) {
+    renderHelp();
+    printThanks(options);
+    return 0;
+  }
+  if (options.version) {
+    const version = await getPackageVersion();
+    renderVersion(version);
+    printThanks(options);
+    return 0;
+  }
+  try {
+    if (options.manageConfig) {
+      return await configCommand();
+    }
+    if (options.manageExclude || options.exclude && options.exclude.length > 0) {
+      return await excludeCommand(options);
+    }
+    if (options.list) {
+      const code = await listCommand(options);
+      printThanks(options);
+      return code;
+    }
+    if (options.all) {
+      return await allCommand(options);
+    }
+    return await interactiveCommand(options);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(`\u2716 Error: ${msg}`);
+    printThanks(options);
+    return 1;
+  }
+}
+if (process.argv[1] && (process.argv[1].endsWith("/cli.ts") || process.argv[1].endsWith("/cli.js") || process.argv[1].endsWith("/quitx"))) {
+  main().then((code) => {
+    if (code !== 0) {
+      process.exit(code);
+    }
+  }).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+export { getPackageVersion, main, parseCliArgs };