killportall 1.0.4 → 1.1.0

package/README.md

@@ -3,8 +3,9 @@
 A powerful cross-platform Node.js CLI tool for efficiently killing processes on specified ports with detailed logging and interactive mode.
 
 [![npm version](https://badge.fury.io/js/killportall.svg)](https://badge.fury.io/js/killportall)
+[![CI](https://github.com/siri1410/killportall/actions/workflows/ci.yml/badge.svg)](https://github.com/siri1410/killportall/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Node.js Version](https://img.shields.io/node/v/killportall.svg)](https://nodejs.org)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org)
 [![Downloads](https://img.shields.io/npm/dm/killportall.svg)](https://www.npmjs.com/package/killportall)
 
 ## Features
@@ -16,6 +17,7 @@ A powerful cross-platform Node.js CLI tool for efficiently killing processes on
 - ⚙️ Configuration file support
 - 🖥️ Cross-platform support (Windows, macOS, Linux)
 - 🎨 JSON output format for scripting
+- ♿ Accessibility support (NO_COLOR, screen reader friendly)
 - 🚀 Fast and efficient port killing
 - 🔍 Debug mode for troubleshooting
 - 🛡️ Robust error handling
@@ -38,6 +40,8 @@ killportall -i
 
 ## Installation
 
+**Requirements:** Node.js >= 18.0.0
+
 ### Global Installation (Recommended)
 ```bash
 npm install -g killportall
@@ -96,8 +100,10 @@ killportall 3000 --timeout 2000
 | `-t, --timeout <ms>` | Timeout between retries | 1000 |
 | `-i, --interactive` | Run in interactive mode | false |
 | `-j, --json` | Output results in JSON format | false |
+| `--no-color` | Disable colored output | - |
+| `--accessible` | Use text labels instead of symbols | - |
 | `--config <key=value>` | Set configuration value | - |
-| `-v, --version` | Display version number | - |
+| `-V, --version` | Display version number | - |
 | `-h, --help` | Display help information | - |
 
 ### Configuration
@@ -123,6 +129,32 @@ DEBUG=killportall:* killportall 3000
 DEBUG=killportall:cli,killportall:config killportall 3000
 ```
 
+### Accessibility
+
+killportall supports accessibility features for users with visual impairments or those using screen readers.
+
+```bash
+# Disable colored output
+killportall 3000 --no-color
+
+# Use text labels instead of symbols (screen reader friendly)
+killportall 3000 --accessible
+# Output: [OK] Port 3000: Process killed successfully
+
+# Combine both for maximum accessibility
+killportall 3000 --no-color --accessible
+```
+
+**Environment Variables:**
+- `NO_COLOR` - Set to any value to disable colors (see [no-color.org](https://no-color.org/))
+- `FORCE_COLOR` - Set to `1` to force colors, `0` to disable
+
+```bash
+# Using environment variables
+NO_COLOR=1 killportall 3000
+FORCE_COLOR=0 killportall 3000
+```
+
 ## API Usage
 
 ```javascript
@@ -198,8 +230,8 @@ npm publish --tag beta
 
 4. Create release:
 ```bash
-git tag v1.0.3
-git push origin v1.0.3
+git tag v1.1.0
+git push origin v1.1.0
 ```
 
 ## Version Guidelines

package/bin/killportall.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander';
-import chalk from 'chalk';
 import debug from 'debug';
 import { killPorts } from '../src/portKiller.js';
 import { validatePorts } from '../src/utils.js';
@@ -10,6 +9,13 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { readFileSync } from 'fs';
 import { loadConfig, saveConfig } from '../src/config.js';
+import {
+  setColorEnabled,
+  setAccessibleMode,
+  setQuietMode,
+  colorize,
+  getSymbol,
+} from '../src/output.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json')));
@@ -26,14 +32,24 @@ program
   .option('-t, --timeout <ms>', 'Timeout between retries in milliseconds', String(config.timeout))
   .option('-i, --interactive', 'Run in interactive mode to select ports from a list', config.interactive)
   .option('-j, --json', 'Output results in JSON format')
+  .option('--no-color', 'Disable colored output')
+  .option('--accessible', 'Use text labels instead of symbols (screen reader friendly)')
   .option('--config <key=value>', 'Set a configuration value (retries, timeout, interactive, outputFormat)')
   .action(async (ports, options) => {
     try {
+      // Handle accessibility options
+      if (options.color === false) {
+        setColorEnabled(false);
+      }
+      if (options.accessible) {
+        setAccessibleMode(true);
+      }
+
       // Handle config setting
       if (options.config) {
         const [key, value] = options.config.split('=');
         if (!key || !value) {
-          console.error(chalk.red('Error: Invalid config format. Use key=value'));
+          console.error(colorize(`${getSymbol('error')} Error: Invalid config format. Use key=value`, 'red'));
           process.exit(1);
         }
         const newConfig = {};
@@ -49,17 +65,17 @@ program
             break;
           case 'outputFormat':
             if (!['text', 'json'].includes(value)) {
-              console.error(chalk.red('Error: outputFormat must be either "text" or "json"'));
+              console.error(colorize(`${getSymbol('error')} Error: outputFormat must be either "text" or "json"`, 'red'));
               process.exit(1);
             }
             newConfig.outputFormat = value;
             break;
           default:
-            console.error(chalk.red(`Error: Unknown config key "${key}"`));
+            console.error(colorize(`${getSymbol('error')} Error: Unknown config key "${key}"`, 'red'));
             process.exit(1);
         }
         if (saveConfig({ ...config, ...newConfig })) {
-          console.log(chalk.green('Configuration saved successfully'));
+          console.log(colorize(`${getSymbol('success')} Configuration saved successfully`, 'green'));
           process.exit(0);
         } else {
           process.exit(1);
@@ -67,8 +83,13 @@ program
       }
 
       debugLog('Starting port killing process with arguments:', { ports, options });
-      
+
       const outputFormat = options.json ? 'json' : config.outputFormat;
+
+      // Enable quiet mode for JSON output to suppress logger messages
+      if (outputFormat === 'json') {
+        setQuietMode(true);
+      }
       let results;
 
       if (options.interactive || config.interactive || ports.length === 0) {
@@ -79,7 +100,7 @@ program
       } else {
         const validatedPorts = validatePorts(ports);
         if (!validatedPorts.length) {
-          console.error(chalk.red('Error: No valid ports specified'));
+          console.error(colorize(`${getSymbol('error')} Error: No valid ports specified`, 'red'));
           process.exit(1);
         }
 
@@ -94,15 +115,15 @@ program
       } else {
         results.forEach(result => {
           if (result.success) {
-            console.log(chalk.green(`✓ Port ${result.port}: Process killed successfully`));
+            console.log(colorize(`${getSymbol('success')} Port ${result.port}: Process killed successfully`, 'green'));
           } else {
-            console.error(chalk.red(`✗ Port ${result.port}: ${result.error}`));
+            console.error(colorize(`${getSymbol('error')} Port ${result.port}: ${result.error}`, 'red'));
           }
         });
       }
 
     } catch (error) {
-      console.error(chalk.red('Error:', error.message));
+      console.error(colorize(`${getSymbol('error')} Error: ${error.message}`, 'red'));
       debugLog('Error details:', error);
       process.exit(1);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killportall",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "A cross-platform Node.js CLI tool for efficiently killing processes on specified ports",
   "type": "module",
   "main": "bin/killportall.js",
@@ -10,10 +10,11 @@
   "files": [
     "bin/",
     "src/",
+    "scripts/",
     "LICENSE"
   ],
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   },
   "directories": {
     "test": "tests"
@@ -22,7 +23,7 @@
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --no-cache",
     "start": "node bin/killportall.js",
     "prepublishOnly": "npm test",
-    "postinstall": "chmod +x bin/killportall.js",
+    "postinstall": "chmod +x bin/killportall.js && node scripts/postinstall.js",
     "preinstall": "node -e \"if(process.env.npm_config_global) { process.exit(0) }\"",
     "setup": "chmod +x bin/killportall.js && npm link --force",
     "clean": "npm unlink -g killportall || true",
@@ -47,11 +48,13 @@
   },
   "homepage": "https://github.com/siri1410/killportall#readme",
   "dependencies": {
-    "chalk": "^5.3.0",
-    "commander": "^12.1.0",
-    "cross-spawn": "^7.0.3",
-    "debug": "^4.3.7",
-    "inquirer": "^12.0.1",
+    "chalk": "^5.4.1",
+    "commander": "^14.0.0",
+    "cross-spawn": "^7.0.6",
+    "debug": "^4.4.0",
+    "inquirer": "^12.3.2"
+  },
+  "devDependencies": {
     "jest": "^29.7.0"
   }
 }

package/scripts/postinstall.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+import { createInterface } from 'readline';
+import { existsSync, appendFileSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const DEFAULT_ALIAS = 'kp';
+
+// Check if colors should be disabled (NO_COLOR support: https://no-color.org/)
+function shouldUseColor() {
+  if (process.env.FORCE_COLOR !== undefined) {
+    return process.env.FORCE_COLOR !== '0';
+  }
+  if (process.env.NO_COLOR !== undefined) {
+    return false;
+  }
+  return process.stdout.isTTY;
+}
+
+const useColor = shouldUseColor();
+
+// ANSI color codes with NO_COLOR support
+const colors = {
+  green: (text) => useColor ? `\x1b[32m${text}\x1b[0m` : text,
+  yellow: (text) => useColor ? `\x1b[33m${text}\x1b[0m` : text,
+  cyan: (text) => useColor ? `\x1b[36m${text}\x1b[0m` : text,
+  red: (text) => useColor ? `\x1b[31m${text}\x1b[0m` : text,
+  bold: (text) => useColor ? `\x1b[1m${text}\x1b[0m` : text,
+};
+
+// Detect user's shell and config file
+function detectShell() {
+  const shell = process.env.SHELL || '';
+  const home = homedir();
+
+  if (shell.includes('zsh')) {
+    return { name: 'zsh', config: join(home, '.zshrc') };
+  } else if (shell.includes('bash')) {
+    // Check for .bash_profile (macOS) or .bashrc (Linux)
+    const bashProfile = join(home, '.bash_profile');
+    const bashrc = join(home, '.bashrc');
+    if (process.platform === 'darwin' && existsSync(bashProfile)) {
+      return { name: 'bash', config: bashProfile };
+    }
+    return { name: 'bash', config: bashrc };
+  } else if (shell.includes('fish')) {
+    return { name: 'fish', config: join(home, '.config/fish/config.fish') };
+  }
+
+  // Default to bashrc
+  return { name: 'bash', config: join(home, '.bashrc') };
+}
+
+// Check if alias already exists
+function aliasExists(configPath, aliasName) {
+  if (!existsSync(configPath)) {
+    return false;
+  }
+  const content = readFileSync(configPath, 'utf8');
+  const aliasPattern = new RegExp(`alias\\s+${aliasName}\\s*=`, 'm');
+  return aliasPattern.test(content);
+}
+
+// Add alias to shell config
+function addAlias(configPath, aliasName, shell) {
+  let aliasLine;
+
+  if (shell === 'fish') {
+    aliasLine = `\n# killportall alias\nalias ${aliasName}='killportall'\n`;
+  } else {
+    aliasLine = `\n# killportall alias\nalias ${aliasName}='killportall'\n`;
+  }
+
+  appendFileSync(configPath, aliasLine);
+  return true;
+}
+
+// Simple readline prompt
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+async function main() {
+  // Skip in CI environments or non-TTY
+  if (process.env.CI || !process.stdin.isTTY) {
+    return;
+  }
+
+  // Skip if running as part of npm install in a project (not global)
+  if (!process.env.npm_config_global) {
+    return;
+  }
+
+  console.log('');
+  console.log(colors.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(colors.bold('  killportall installed successfully! 🎉'));
+  console.log(colors.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log('');
+
+  const shell = detectShell();
+
+  console.log(`  Detected shell: ${colors.green(shell.name)}`);
+  console.log(`  Config file: ${colors.yellow(shell.config)}`);
+  console.log('');
+
+  const setupAlias = await prompt(`  Would you like to set up a shell alias? (y/n) [y]: `);
+
+  if (setupAlias.toLowerCase() !== 'n') {
+    const customAlias = await prompt(`  Enter alias name [${DEFAULT_ALIAS}]: `);
+    const aliasName = customAlias.trim() || DEFAULT_ALIAS;
+
+    if (aliasExists(shell.config, aliasName)) {
+      console.log('');
+      console.log(colors.yellow(`  ⚠ Alias '${aliasName}' already exists in ${shell.config}`));
+      console.log('');
+    } else {
+      try {
+        addAlias(shell.config, aliasName, shell.name);
+        console.log('');
+        console.log(colors.green(`  ✓ Alias '${aliasName}' added to ${shell.config}`));
+        console.log('');
+        console.log(colors.cyan('  To use the alias now, run:'));
+        console.log(`    ${colors.bold(`source ${shell.config}`)}`);
+        console.log('');
+        console.log(colors.cyan('  Or simply open a new terminal window.'));
+        console.log('');
+      } catch (error) {
+        console.log('');
+        console.log(colors.red(`  ✗ Failed to add alias: ${error.message}`));
+        console.log('');
+        console.log(colors.yellow('  You can manually add this to your shell config:'));
+        console.log(`    ${colors.bold(`alias ${aliasName}='killportall'`)}`);
+        console.log('');
+      }
+    }
+  } else {
+    console.log('');
+    console.log(colors.yellow('  Skipping alias setup.'));
+    console.log('');
+    console.log(colors.cyan('  You can manually add an alias later:'));
+    console.log(`    ${colors.bold(`alias ${DEFAULT_ALIAS}='killportall'`)}`);
+    console.log('');
+  }
+
+  console.log(colors.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(`  Usage: ${colors.bold('killportall 3000')} or ${colors.bold('killportall -i')}`);
+  console.log(colors.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log('');
+}
+
+main().catch(() => {
+  // Silently fail - don't block installation
+});

package/src/logger.js

@@ -1,26 +1,34 @@
-import chalk from 'chalk';
 import debug from 'debug';
+import { formatMessage, isQuietMode } from './output.js';
 
 const debugLog = debug('killportall:logger');
 
 class Logger {
   info(message) {
-    console.log(chalk.blue('ℹ'), message);
+    if (!isQuietMode()) {
+      console.log(formatMessage(message, 'info'));
+    }
     debugLog('INFO:', message);
   }
 
   success(message) {
-    console.log(chalk.green('✓'), message);
+    if (!isQuietMode()) {
+      console.log(formatMessage(message, 'success'));
+    }
     debugLog('SUCCESS:', message);
   }
 
   warn(message) {
-    console.log(chalk.yellow('⚠'), message);
+    if (!isQuietMode()) {
+      console.error(formatMessage(message, 'warning'));
+    }
     debugLog('WARN:', message);
   }
 
   error(message) {
-    console.error(chalk.red('✗'), message);
+    if (!isQuietMode()) {
+      console.error(formatMessage(message, 'error'));
+    }
     debugLog('ERROR:', message);
   }
 }

package/src/output.js

@@ -0,0 +1,129 @@
+import chalk from 'chalk';
+
+/**
+ * Centralized output utility for accessibility and color handling.
+ * Supports NO_COLOR (https://no-color.org/) and FORCE_COLOR environment variables.
+ */
+
+// Determine color support
+function shouldUseColor() {
+  // FORCE_COLOR takes precedence
+  if (process.env.FORCE_COLOR !== undefined) {
+    return process.env.FORCE_COLOR !== '0';
+  }
+  // NO_COLOR disables colors (https://no-color.org/)
+  if (process.env.NO_COLOR !== undefined) {
+    return false;
+  }
+  // Check if chalk has color support
+  return chalk.level > 0;
+}
+
+// Configuration state
+const config = {
+  useColor: shouldUseColor(),
+  useAccessibleSymbols: false,
+  quiet: false,
+};
+
+/**
+ * Set whether to use colors in output
+ * @param {boolean} enabled
+ */
+export function setColorEnabled(enabled) {
+  config.useColor = enabled;
+}
+
+/**
+ * Set whether to use accessible text labels instead of symbols
+ * @param {boolean} enabled
+ */
+export function setAccessibleMode(enabled) {
+  config.useAccessibleSymbols = enabled;
+}
+
+/**
+ * Set quiet mode (suppress non-JSON output for --json flag)
+ * @param {boolean} enabled
+ */
+export function setQuietMode(enabled) {
+  config.quiet = enabled;
+}
+
+/**
+ * Check if colors are currently enabled
+ * @returns {boolean}
+ */
+export function isColorEnabled() {
+  return config.useColor;
+}
+
+/**
+ * Check if accessible mode is enabled
+ * @returns {boolean}
+ */
+export function isAccessibleMode() {
+  return config.useAccessibleSymbols;
+}
+
+/**
+ * Check if quiet mode is enabled
+ * @returns {boolean}
+ */
+export function isQuietMode() {
+  return config.quiet;
+}
+
+// Symbol definitions with accessible alternatives
+const symbols = {
+  info: { symbol: '\u2139', accessible: '[INFO]' },      // ℹ
+  success: { symbol: '\u2713', accessible: '[OK]' },     // ✓
+  warning: { symbol: '\u26A0', accessible: '[WARN]' },   // ⚠
+  error: { symbol: '\u2717', accessible: '[ERROR]' },    // ✗
+};
+
+/**
+ * Get the appropriate symbol or text label
+ * @param {'info' | 'success' | 'warning' | 'error'} type
+ * @returns {string}
+ */
+export function getSymbol(type) {
+  const def = symbols[type];
+  if (!def) return '';
+  return config.useAccessibleSymbols ? def.accessible : def.symbol;
+}
+
+/**
+ * Apply color to text if colors are enabled
+ * @param {string} text
+ * @param {'blue' | 'green' | 'yellow' | 'red' | 'cyan' | 'bold'} color
+ * @returns {string}
+ */
+export function colorize(text, color) {
+  if (!config.useColor) {
+    return text;
+  }
+  const colorFn = chalk[color];
+  return colorFn ? colorFn(text) : text;
+}
+
+/**
+ * Format a message with symbol and color
+ * @param {string} message
+ * @param {'info' | 'success' | 'warning' | 'error'} type
+ * @returns {string}
+ */
+export function formatMessage(message, type) {
+  const symbol = getSymbol(type);
+  const colorMap = {
+    info: 'blue',
+    success: 'green',
+    warning: 'yellow',
+    error: 'red',
+  };
+  const coloredSymbol = colorize(symbol, colorMap[type]);
+  return `${coloredSymbol} ${message}`;
+}
+
+// Re-export chalk for direct use when needed
+export { chalk };