fix: harden cli port handling and add tests

Author: luckfunc

index.js

@@ -1,78 +1,11 @@
 #!/usr/bin/env node
-const { exec } = require('child_process');
+const { runCli } = require('./lib/kill-port');
 
-// 获取命令行参数
-const args = process.argv.slice(2);
-
-if (args.length < 1) {
-  console.error('Usage: kill-port <port1> [<port2> ...]');
-  process.exit(1);
-}
-
-const ports = args.map(port => parseInt(port, 10)).filter(port => !isNaN(port));
-
-if (ports.length === 0) {
-  console.error('Invalid port number(s)');
-  process.exit(1);
-}
-
-const findPidCommand = port => process.platform === 'win32'
-  ? `netstat -ano | findstr :${port}`
-  : `lsof -i:${port} -t`;
-
-const killCommand = pid => process.platform === 'win32'
-  ? `taskkill /PID ${pid} /F`
-  : `kill -9 ${pid}`;
-
-const findAndKillProcess = (port) => {
-  return new Promise((resolve, reject) => {
-    // 查找占用指定端口的进程ID
-    exec(findPidCommand(port), (err, stdout, stderr) => {
-      if (err || stderr) {
-        resolve(`Port ${port} is not in use.`);
-        return;
-      }
-
-      const pids = process.platform === 'win32'
-        ? stdout
-          .split('\n')
-          .filter(line => line.includes('LISTEN'))
-          .map(line => line.trim().split(/\s+/).pop())
-          .filter(Boolean)
-        : stdout.split('\n').map(line => line.trim()).filter(Boolean);
-
-      if (pids.length === 0) {
-        resolve(`No process found on port ${port}`);
-        return;
-      }
-
-      console.log(`Found processes on port ${port} with PIDs: ${pids.join(', ')}`);
-
-      Promise.all(
-        pids.map(pid =>
-          new Promise((killResolve, killReject) => {
-            exec(killCommand(pid), (killErr, killStdout, killStderr) => {
-              if (killErr || killStderr) {
-                killReject(`Error killing process ${pid}: ${killErr || killStderr}`);
-                return;
-              }
-              killResolve(`Process ${pid} killed successfully on port ${port}.`);
-            });
-          })
-        )
-      )
-        .then(killResults => resolve(killResults.join('\n')))
-        .catch(killErr => reject(killErr));
-    });
-  });
-};
-
-
-// 并行处理所有端口
-Promise.all(ports.map(findAndKillProcess))
-  .then(results => {
-    results.forEach(result => console.log(result));
+runCli(process.argv.slice(2))
+  .then((exitCode) => {
+    process.exitCode = exitCode;
   })
-  .catch(err => {
-    console.error(err);
+  .catch((error) => {
+    console.error(error.message);
+    process.exitCode = 1;
   });

lib/kill-port.js

@@ -0,0 +1,241 @@
+const { exec } = require('child_process');
+
+const USAGE_MESSAGE = 'Usage: kill-port <port1> [<port2> ...]';
+const PORT_PATTERN = /^\d+$/;
+const PID_PATTERN = /^\d+$/;
+const MIN_PORT = 1;
+const MAX_PORT = 65535;
+
+function parseAndValidatePortArgs(args) {
+  if (args.length === 0) {
+    return { error: USAGE_MESSAGE };
+  }
+
+  const invalidTokens = args.filter((token) => !isValidPortArgument(token));
+
+  if (invalidTokens.length > 0) {
+    return { error: `Invalid port number(s): ${invalidTokens.join(', ')}` };
+  }
+
+  return {
+    ports: [...new Set(args.map((token) => Number(token)))],
+  };
+}
+
+function isValidPortArgument(token) {
+  if (!PORT_PATTERN.test(token)) {
+    return false;
+  }
+
+  const port = Number(token);
+  return Number.isInteger(port) && port >= MIN_PORT && port <= MAX_PORT;
+}
+
+function createPlatformProcessCommands(platform) {
+  if (platform === 'win32') {
+    return {
+      buildPortLookupCommand: (port) => `netstat -ano | findstr :${port}`,
+      buildProcessKillCommand: (processId) => `taskkill /PID ${processId} /F`,
+      extractProcessIds: (stdout) => stdout
+        .split('\n')
+        .filter((line) => line.includes('LISTEN'))
+        .map((line) => line.trim().split(/\s+/).pop())
+        .filter((processId) => PID_PATTERN.test(processId)),
+    };
+  }
+
+  return {
+    buildPortLookupCommand: (port) => `lsof -i:${port} -t`,
+    buildProcessKillCommand: (processId) => `kill -9 ${processId}`,
+    extractProcessIds: (stdout) => stdout
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((processId) => PID_PATTERN.test(processId)),
+  };
+}
+
+function executeShellCommand(command, execFn = exec) {
+  return new Promise((resolve, reject) => {
+    execFn(command, (error, stdout = '', stderr = '') => {
+      if (error) {
+        const commandError = new Error(stderr.trim() || error.message.trim());
+        commandError.code = error.code;
+        commandError.command = command;
+        commandError.stdout = stdout;
+        commandError.stderr = stderr;
+        reject(commandError);
+        return;
+      }
+
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+function isLookupCommandNoMatchError(error) {
+  if (!error || error.code !== 1) {
+    return false;
+  }
+
+  // `lsof` and `findstr` both use exit code 1 with empty output to signal "no matches".
+  return error.stdout.trim() === '' && error.stderr.trim() === '';
+}
+
+async function killPorts(ports, options = {}) {
+  const executionContext = createExecutionContext(options);
+  const tasks = ports.map((port) => killProcessesOnPort(port, executionContext));
+  return Promise.all(tasks);
+}
+
+function createExecutionContext(options) {
+  const platform = options.platform || process.platform;
+
+  return {
+    execFn: options.execFn || exec,
+    platform,
+    platformCommands: options.platformCommands || createPlatformProcessCommands(platform),
+  };
+}
+
+async function killProcessesOnPort(port, executionContext) {
+  let processIds;
+
+  try {
+    processIds = await findProcessIdsUsingPort(port, executionContext);
+  } catch (error) {
+    return {
+      ok: false,
+      port,
+      status: 'inspect_error',
+      message: `Failed to inspect port ${port}: ${error.message}`,
+    };
+  }
+
+  if (processIds.length === 0) {
+    return {
+      ok: true,
+      port,
+      status: 'not_in_use',
+      message: `Port ${port} is not in use.`,
+    };
+  }
+
+  const killAttemptResults = await Promise.all(
+    processIds.map((processId) => killProcessId(processId, port, executionContext))
+  );
+
+  const killedProcessIds = killAttemptResults
+    .filter((result) => result.ok)
+    .map((result) => result.pid);
+  const failedKillAttempts = killAttemptResults.filter((result) => !result.ok);
+
+  if (failedKillAttempts.length === 0) {
+    return {
+      ok: true,
+      port,
+      status: 'killed',
+      message: formatKilledProcessMessage(port, killedProcessIds),
+    };
+  }
+
+  if (killedProcessIds.length === 0) {
+    return {
+      ok: false,
+      port,
+      status: 'kill_error',
+      message: `Failed to kill processes on port ${port}: ${formatFailedKillAttempts(failedKillAttempts)}`,
+    };
+  }
+
+  return {
+    ok: false,
+    port,
+    status: 'partial_kill_error',
+    message: `Port ${port}: killed PIDs ${killedProcessIds.join(', ')}; failed to kill ${formatFailedKillAttempts(failedKillAttempts)}`,
+  };
+}
+
+async function findProcessIdsUsingPort(port, executionContext) {
+  try {
+    const { stdout } = await executeShellCommand(
+      executionContext.platformCommands.buildPortLookupCommand(port),
+      executionContext.execFn
+    );
+
+    return dedupeValues(executionContext.platformCommands.extractProcessIds(stdout));
+  } catch (error) {
+    if (isLookupCommandNoMatchError(error)) {
+      return [];
+    }
+
+    throw error;
+  }
+}
+
+async function killProcessId(processId, port, executionContext) {
+  try {
+    await executeShellCommand(
+      executionContext.platformCommands.buildProcessKillCommand(processId),
+      executionContext.execFn
+    );
+    return { ok: true, pid: processId };
+  } catch (error) {
+    return {
+      ok: false,
+      pid: processId,
+      error: `PID ${processId} (${error.message})`,
+      port,
+    };
+  }
+}
+
+function formatKilledProcessMessage(port, processIds) {
+  if (processIds.length === 1) {
+    return `Killed process ${processIds[0]} on port ${port}.`;
+  }
+
+  return `Killed processes on port ${port}: ${processIds.join(', ')}.`;
+}
+
+function formatFailedKillAttempts(failedKillAttempts) {
+  return failedKillAttempts.map((failure) => failure.error).join('; ');
+}
+
+function dedupeValues(values) {
+  return [...new Set(values)];
+}
+
+async function runCli(args, options = {}) {
+  const parsedPortArgs = parseAndValidatePortArgs(args);
+  const writeStdout = options.stdout || console.log;
+  const writeStderr = options.stderr || console.error;
+
+  if (parsedPortArgs.error) {
+    writeStderr(parsedPortArgs.error);
+    return 1;
+  }
+
+  const portResults = await killPorts(parsedPortArgs.ports, options);
+
+  portResults.forEach((result) => {
+    if (result.ok) {
+      writeStdout(result.message);
+      return;
+    }
+
+    writeStderr(result.message);
+  });
+
+  return portResults.every((result) => result.ok) ? 0 : 1;
+}
+
+module.exports = {
+  USAGE_MESSAGE,
+  createPlatformProcessCommands,
+  executeShellCommand,
+  isLookupCommandNoMatchError,
+  isValidPortArgument,
+  killPorts,
+  parseAndValidatePortArgs,
+  runCli,
+};

package-lock.json

@@ -1,10 +1,11 @@
 {
   "name": "kill-port-process-cli",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "A CLI tool to kill processes by port",
   "main": "index.js",
   "files": [
     "index.js",
+    "lib",
     "README.md",
     "LICENSE"
   ],
@@ -14,7 +15,7 @@
     "k": "index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test"
   },
   "repository": {
     "type": "git",