@burakboduroglu/portkill 0.4.1

package/dist/index.js

@@ -0,0 +1,1308 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import process6 from "process";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/commands/kill.ts
+import * as readline from "readline/promises";
+import process3 from "process";
+
+// src/core/finder.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var defaultExecFile = (file, args, options) => execFileAsync(file, args, options);
+function parseLsofListenTable(stdout) {
+  const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
+  if (lines.length === 0) return [];
+  const dataLines = lines[0]?.startsWith("COMMAND") ? lines.slice(1) : lines;
+  const byPid = /* @__PURE__ */ new Map();
+  for (const line of dataLines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    const commandName = parts[0] ?? null;
+    const pidRaw = parts[1];
+    const pid = pidRaw ? Number.parseInt(pidRaw, 10) : Number.NaN;
+    if (!Number.isFinite(pid)) continue;
+    if (!byPid.has(pid)) {
+      byPid.set(pid, { pid, commandName: commandName ?? null });
+    }
+  }
+  return [...byPid.values()].sort((a, b) => a.pid - b.pid);
+}
+function parseFuserCombined(output) {
+  const colonIdx = output.indexOf(":");
+  const tail = colonIdx >= 0 ? output.slice(colonIdx + 1) : output;
+  const pids = tail.split(/\s+/).map((s) => s.trim()).filter(Boolean).map((s) => Number.parseInt(s, 10)).filter((n) => Number.isFinite(n));
+  return [...new Set(pids)].sort((a, b) => a - b);
+}
+async function findWithLsof(port, execFileFn) {
+  try {
+    const { stdout } = await execFileFn("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN"], {
+      encoding: "utf8"
+    });
+    const list = parseLsofListenTable(stdout);
+    return list.length === 0 ? "empty" : list;
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === 1) {
+      return "empty";
+    }
+    if (code === "ENOENT") {
+      return "error";
+    }
+    return "error";
+  }
+}
+async function findWithFuser(port, execFileFn) {
+  try {
+    const { stdout, stderr } = await execFileFn("fuser", ["-n", "tcp", String(port)], {
+      encoding: "utf8"
+    });
+    const combined = `${stdout}
+${stderr}`;
+    const pids = parseFuserCombined(combined);
+    if (pids.length === 0) return "empty";
+    return pids.map((pid) => ({ pid, commandName: null }));
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === 1) return "empty";
+    if (code === "ENOENT") return "error";
+    return "error";
+  }
+}
+async function findListeners(port, platform, options = {}) {
+  const execFileFn = options.execFile ?? defaultExecFile;
+  const lsofResult = await findWithLsof(port, execFileFn);
+  if (Array.isArray(lsofResult)) {
+    return { ok: true, processes: lsofResult };
+  }
+  if (lsofResult === "empty") {
+    return { ok: true, processes: [] };
+  }
+  if (platform === "linux") {
+    const fuserResult = await findWithFuser(port, execFileFn);
+    if (Array.isArray(fuserResult)) {
+      return { ok: true, processes: fuserResult };
+    }
+    if (fuserResult === "empty") {
+      return { ok: true, processes: [] };
+    }
+  }
+  return {
+    ok: false,
+    message: platform === "linux" ? "Could not list listeners (install `lsof` or `fuser`, or check PATH)." : "Could not list listeners (`lsof` failed or is missing)."
+  };
+}
+
+// src/core/killer.ts
+import process2 from "process";
+var defaultKill = (pid, signal) => {
+  process2.kill(pid, signal);
+};
+function killPid(pid, signal = "SIGTERM", killFn = defaultKill) {
+  try {
+    killFn(pid, signal);
+    return { ok: true };
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
+    if (code === "EPERM") {
+      return { ok: false, permissionDenied: true };
+    }
+    if (code === "ESRCH") {
+      return { ok: true };
+    }
+    return { ok: false, permissionDenied: false };
+  }
+}
+
+// src/utils/exit-code.ts
+function aggregateExitCode(outcomes) {
+  if (outcomes.length === 0) return 0;
+  if (outcomes.some((o) => o.kind === "permissionDenied")) return 3;
+  if (outcomes.some((o) => o.kind === "error")) return 1;
+  if (outcomes.every((o) => o.kind === "notFound")) return 2;
+  return 0;
+}
+
+// src/utils/style.ts
+import chalk from "chalk";
+var style = {
+  success: (text) => chalk.green(text),
+  info: (text) => chalk.cyan(text),
+  error: (text) => chalk.red(text),
+  listRow: (port, commandName, pid) => `${chalk.white("\u2022 Port ")}${chalk.bold.yellow(String(port))}${chalk.white(` \u2192 ${commandName} (PID ${pid})`)}`
+};
+
+// src/utils/output.ts
+function formatOutcomeLine(outcome) {
+  switch (outcome.kind) {
+    case "notFound":
+      return style.info(`\u2139 Port ${outcome.port} \u2192 no process found`);
+    case "killed":
+      return style.success(
+        `\u2714 Port ${outcome.port} \u2192 killed (${outcome.commandName ?? "unknown"}, PID ${outcome.pid})`
+      );
+    case "dryRunWouldKill":
+      return style.info(
+        `\u2139 Port ${outcome.port} \u2192 ${outcome.commandName ?? "unknown"} (PID ${outcome.pid}) \u2014 dry-run (no signal sent)`
+      );
+    case "permissionDenied":
+      return style.error(`\u2716 Port ${outcome.port} \u2192 permission denied (try with sudo)`);
+    case "error":
+      return style.error(`\u2716 Port ${outcome.port} \u2192 ${outcome.message}`);
+    default: {
+      const _exhaustive = outcome;
+      return _exhaustive;
+    }
+  }
+}
+
+// src/commands/kill.ts
+function logVerbose(verbose, message) {
+  if (verbose) {
+    process3.stderr.write(`[verbose] ${message}
+`);
+  }
+}
+async function confirmKill(summary) {
+  if (!process3.stdin.isTTY) {
+    return false;
+  }
+  const rl = readline.createInterface({ input: process3.stdin, output: process3.stdout });
+  try {
+    const answer = (await rl.question(`${summary} [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function normalizeSignal(signal) {
+  if (typeof signal === "number") return signal;
+  if (typeof signal !== "string") return signal;
+  const n = Number.parseInt(signal, 10);
+  if (Number.isFinite(n)) return n;
+  return signal;
+}
+async function runKill(opts) {
+  const signal = normalizeSignal(opts.signal);
+  const phases = [];
+  for (const port of opts.ports) {
+    logVerbose(opts.verbose, `finding listeners on TCP ${port}`);
+    const found = await findListeners(port, opts.platform);
+    if (!found.ok) {
+      phases.push({ kind: "resolved", outcome: { kind: "error", port, message: found.message } });
+      continue;
+    }
+    if (found.processes.length === 0) {
+      phases.push({ kind: "resolved", outcome: { kind: "notFound", port } });
+      continue;
+    }
+    phases.push({ kind: "pendingKill", port, processes: found.processes });
+  }
+  const pending = phases.filter((p) => p.kind === "pendingKill");
+  const describe = (port, processes) => {
+    const first = processes[0];
+    const extra = processes.length > 1 ? ` (+${processes.length - 1} more)` : "";
+    const name = first?.commandName ?? "unknown";
+    const pid = first?.pid ?? 0;
+    return `port ${port}: ${name} (PID ${pid})${extra}`;
+  };
+  if (!opts.dryRun && pending.length > 0 && !opts.force) {
+    if (!process3.stdin.isTTY) {
+      process3.stderr.write("Not a TTY: use --force to kill without confirmation, or use --dry-run.\n");
+      return { exitCode: 1, lines: [], outcomes: [] };
+    }
+    const lines2 = pending.map((p) => describe(p.port, p.processes));
+    const summary = `Kill process(es)?
+${lines2.map((l) => `  - ${l}`).join("\n")}
+`;
+    const ok = await confirmKill(summary);
+    if (!ok) {
+      process3.stderr.write("Aborted.\n");
+      return { exitCode: 1, lines: [], outcomes: [] };
+    }
+  }
+  const outcomes = [];
+  for (const phase of phases) {
+    if (phase.kind === "resolved") {
+      outcomes.push(phase.outcome);
+      continue;
+    }
+    const { port, processes } = phase;
+    const display = processes[0];
+    const displayPid = display?.pid ?? 0;
+    const displayName = display?.commandName ?? null;
+    if (opts.dryRun) {
+      outcomes.push({
+        kind: "dryRunWouldKill",
+        port,
+        pid: displayPid,
+        commandName: displayName
+      });
+      continue;
+    }
+    let denied = false;
+    let otherError = false;
+    for (const proc of processes) {
+      logVerbose(opts.verbose, `sending ${String(signal)} to PID ${proc.pid}`);
+      const result = killPid(proc.pid, signal, opts.killFn);
+      if (!result.ok) {
+        if (result.permissionDenied) denied = true;
+        else otherError = true;
+      }
+    }
+    if (denied) {
+      outcomes.push({ kind: "permissionDenied", port });
+    } else if (otherError) {
+      outcomes.push({
+        kind: "error",
+        port,
+        message: "failed to send signal to one or more processes"
+      });
+    } else {
+      outcomes.push({
+        kind: "killed",
+        port,
+        pid: displayPid,
+        commandName: displayName
+      });
+    }
+  }
+  const lines = outcomes.map(formatOutcomeLine);
+  const exitCode = aggregateExitCode(outcomes);
+  return { exitCode, lines, outcomes };
+}
+
+// src/commands/list.ts
+import process4 from "process";
+
+// src/core/lister.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var defaultExecFile2 = (file, args, options) => execFileAsync2(file, args, options);
+function parseLsofListenLine(line) {
+  if (!line.includes("(LISTEN)") || !line.includes("TCP")) return null;
+  const portMatch = line.match(/TCP .+:(\d+) \(LISTEN\)/);
+  if (!portMatch?.[1]) return null;
+  const port = Number.parseInt(portMatch[1], 10);
+  if (!Number.isFinite(port)) return null;
+  const head = line.match(/^(\S+)\s+(\d+)\s+/);
+  if (!head?.[1] || !head[2]) return null;
+  const pid = Number.parseInt(head[2], 10);
+  if (!Number.isFinite(pid)) return null;
+  return { port, pid, commandName: head[1] };
+}
+async function listAllTcpListeners(_platform, options = {}) {
+  const execFileFn = options.execFile ?? defaultExecFile2;
+  try {
+    const { stdout } = await execFileFn("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN"], { encoding: "utf8" });
+    const seen = /* @__PURE__ */ new Set();
+    const rows = [];
+    for (const line of stdout.split(/\r?\n/)) {
+      const row = parseLsofListenLine(line);
+      if (!row) continue;
+      const key = `${row.port}\0${row.pid}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      rows.push(row);
+    }
+    rows.sort((a, b) => a.port - b.port || a.pid - b.pid);
+    return { ok: true, rows };
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === 1) {
+      return { ok: true, rows: [] };
+    }
+    return {
+      ok: false,
+      message: "Could not list listeners (`lsof` failed or is missing). Install `lsof` or check PATH."
+    };
+  }
+}
+
+// src/commands/list.ts
+async function runList(opts) {
+  if (opts.verbose) {
+    process4.stderr.write("[verbose] running lsof -nP -iTCP -sTCP:LISTEN\n");
+  }
+  const result = await listAllTcpListeners(opts.platform);
+  if (!result.ok) {
+    return { exitCode: 1, lines: [style.error(`\u2716 ${result.message}`)] };
+  }
+  if (result.rows.length === 0) {
+    return { exitCode: 0, lines: [style.info("\u2139 No TCP listeners found.")] };
+  }
+  const lines = result.rows.map((r) => style.listRow(r.port, r.commandName, r.pid));
+  return { exitCode: 0, lines };
+}
+
+// src/gui/server.ts
+import {
+  createServer
+} from "http";
+import process5 from "process";
+
+// src/utils/parse-ports.ts
+var SINGLE = /^(\d+)$/;
+var RANGE = /^(\d+)-(\d+)$/;
+var MAX_PORTS_PER_RANGE = 4096;
+function assertPort(n, label) {
+  if (!Number.isFinite(n) || n < 1 || n > 65535) {
+    throw new Error(`invalid port in ${label}`);
+  }
+}
+function expandPortToken(token) {
+  const t = token.trim();
+  if (!t) {
+    throw new Error(`invalid port: ${JSON.stringify(token)}`);
+  }
+  const rangeMatch = t.match(RANGE);
+  if (rangeMatch) {
+    const start = Number.parseInt(rangeMatch[1], 10);
+    const end = Number.parseInt(rangeMatch[2], 10);
+    assertPort(start, "range start");
+    assertPort(end, "range end");
+    if (start > end) {
+      throw new Error(`invalid port range: ${t} (start must be <= end)`);
+    }
+    const count = end - start + 1;
+    if (count > MAX_PORTS_PER_RANGE) {
+      throw new Error(`port range too large: ${count} ports (max ${MAX_PORTS_PER_RANGE} per range)`);
+    }
+    const out = [];
+    for (let p = start; p <= end; p++) {
+      out.push(p);
+    }
+    return out;
+  }
+  const singleMatch = t.match(SINGLE);
+  if (singleMatch) {
+    const n = Number.parseInt(singleMatch[1], 10);
+    assertPort(n, t);
+    return [n];
+  }
+  throw new Error(`invalid port: ${t}`);
+}
+function parsePortArguments(tokens) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    for (const port of expandPortToken(token)) {
+      if (!seen.has(port)) {
+        seen.add(port);
+        result.push(port);
+      }
+    }
+  }
+  return result;
+}
+
+// src/gui/index-html.ts
+function getIndexHtml() {
+  const faviconSvg = '<svg xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" width="100" height="100" viewBox="0 0 48 48"><path fill="#F44336" d="M21.5 4.5H26.501V43.5H21.5z" transform="rotate(45.001 24 24)"/><path fill="#F44336" d="M21.5 4.5H26.5V43.501H21.5z" transform="rotate(135.008 24 24)"/></svg>';
+  const faviconHref = `data:image/svg+xml,${encodeURIComponent(faviconSvg)}`;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>.portkill</title>
+  <link rel="icon" type="image/svg+xml" href="${faviconHref}" />
+  <style>
+    :root {
+      --ink: #163300;
+      --ink-secondary: #3a4d39;
+      --muted: #687385;
+      --surface: #ffffff;
+      --canvas: #f2f5f0;
+      --border: #d3dcd3;
+      --border-strong: #b8c4b8;
+      --focus: #163300;
+      --primary: #9fe870;
+      --primary-hover: #8fd960;
+      --primary-ink: #163300;
+      --danger: #b42318;
+      --danger-surface: #fef3f2;
+      --danger-border: #fecdca;
+      --info-bg: #eef6ff;
+      --info-border: #c7d9f5;
+      --success-text: #0d532a;
+      --warn-text: #7a5c00;
+      --radius-lg: 16px;
+      --radius-md: 12px;
+      --radius-sm: 8px;
+      --shadow: 0 1px 2px rgba(22, 51, 0, 0.06), 0 4px 16px rgba(22, 51, 0, 0.04);
+      font-family: "Inter", ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+    }
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --ink: #e8f0e8;
+        --ink-secondary: #c5d4c5;
+        --muted: #9aa89a;
+        --surface: #1c221c;
+        --canvas: #121612;
+        --border: #2e382e;
+        --border-strong: #3d4a3d;
+        --focus: #9fe870;
+        --primary: #9fe870;
+        --primary-hover: #b5f090;
+        --primary-ink: #163300;
+        --danger: #f97066;
+        --danger-surface: #2a1816;
+        --danger-border: #5c2f2a;
+        --info-bg: #1a2430;
+        --info-border: #3a4a62;
+        --success-text: #7ee787;
+        --warn-text: #f5d565;
+        --shadow: 0 1px 2px rgba(0,0,0,0.2), 0 4px 20px rgba(0,0,0,0.25);
+      }
+    }
+    * { box-sizing: border-box; }
+    html {
+      height: 100%;
+      overflow-y: scroll;
+      scrollbar-gutter: stable;
+    }
+    body {
+      margin: 0;
+      height: 100%;
+      background: var(--canvas);
+      color: var(--ink);
+      line-height: 1.5;
+      font-size: 14px;
+      padding: clamp(0.65rem, 1.5vw, 1rem) clamp(0.75rem, 2vw, 1.25rem);
+      overflow: hidden;
+    }
+    .wrap {
+      max-width: 58rem;
+      margin: 0 auto;
+      height: 100%;
+      max-height: 100%;
+      min-height: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 0.5rem;
+    }
+    .masthead {
+      display: flex;
+      flex-wrap: wrap;
+      align-items: baseline;
+      gap: 0.25rem 1.25rem;
+      flex-shrink: 0;
+    }
+    .masthead .page-title { margin: 0; }
+    .page-title {
+      font-size: clamp(1.35rem, 3vw, 1.65rem);
+      font-weight: 600;
+      letter-spacing: -0.02em;
+      margin: 0 0 0.35rem;
+      color: var(--ink);
+      line-height: 1.15;
+    }
+    .page-title .title-dot {
+      color: var(--primary);
+      font-weight: 800;
+      margin-right: 0.02em;
+      position: relative;
+      top: 0.03em;
+    }
+    .lede {
+      margin: 0;
+      color: var(--muted);
+      font-size: 0.8125rem;
+      flex: 1;
+      min-width: 14rem;
+      max-width: 36rem;
+    }
+    .info-prompt {
+      display: flex;
+      gap: 0.5rem;
+      align-items: center;
+      padding: 0.45rem 0.75rem;
+      background: var(--info-bg);
+      border: 1px solid var(--info-border);
+      border-radius: var(--radius-sm);
+      font-size: 0.75rem;
+      color: var(--ink-secondary);
+      margin: 0;
+      flex-shrink: 0;
+    }
+    .info-prompt strong { color: var(--ink); }
+    .panel-unified {
+      flex: 1;
+      min-height: 0;
+      display: flex;
+      flex-direction: column;
+      background: var(--surface);
+      border-radius: var(--radius-lg);
+      border: 1px solid var(--border);
+      box-shadow: var(--shadow);
+      overflow: hidden;
+    }
+    .action-bar {
+      flex-shrink: 0;
+      padding: 0.75rem 1rem 0.85rem;
+      border-bottom: 1px solid var(--border);
+      background: var(--canvas);
+    }
+    .action-bar-title {
+      font-size: 0.65rem;
+      font-weight: 600;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+      color: var(--muted);
+      margin: 0 0 0.5rem;
+    }
+    .actions {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 0.4rem;
+    }
+    .action-bar .hint {
+      font-size: 0.6875rem;
+      color: var(--muted);
+      margin: 0.5rem 0 0;
+      line-height: 1.4;
+    }
+    .panel-split {
+      flex: 1;
+      min-height: 0;
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+      gap: 0;
+    }
+    .col {
+      padding: 0.85rem 1rem;
+      min-height: 0;
+      display: flex;
+      flex-direction: column;
+    }
+    .col--controls {
+      overflow-y: scroll;
+      overflow-x: hidden;
+    }
+    .col--results {
+      border-left: 1px solid var(--border);
+      background: var(--surface);
+    }
+    .panel-footer {
+      flex-shrink: 0;
+      border-top: 1px solid var(--border);
+      padding: 0.4rem 0.75rem;
+      text-align: center;
+      font-size: 0.6875rem;
+      color: var(--muted);
+      line-height: 1.4;
+    }
+    .panel-footer .heart { color: #c41e3a; }
+    .section-header {
+      font-size: 0.65rem;
+      font-weight: 600;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      color: var(--muted);
+      margin: 0 0 0.3rem;
+    }
+    .section-title {
+      font-size: 0.9375rem;
+      font-weight: 600;
+      margin: 0 0 0.35rem;
+      color: var(--ink);
+      letter-spacing: -0.01em;
+    }
+    .supporting {
+      font-size: 0.75rem;
+      color: var(--muted);
+      margin: 0 0 0.45rem;
+      line-height: 1.45;
+    }
+    .field { margin-bottom: 0.65rem; }
+    .field:last-child { margin-bottom: 0; }
+    .label {
+      display: block;
+      font-size: 0.75rem;
+      font-weight: 500;
+      color: var(--ink);
+      margin-bottom: 0.3rem;
+    }
+    .textarea, .input, .select {
+      width: 100%;
+      padding: 0.55rem 0.65rem;
+      border-radius: var(--radius-sm);
+      border: 1px solid var(--border-strong);
+      background: var(--surface);
+      color: var(--ink);
+      font-size: 0.875rem;
+      font-family: ui-monospace, "SF Mono", Consolas, monospace;
+      transition: border-color 0.15s, box-shadow 0.15s;
+    }
+    .textarea { min-height: 3.25rem; resize: none; line-height: 1.45; }
+    .textarea:focus, .input:focus, .select:focus {
+      outline: none;
+      border-color: var(--focus);
+      box-shadow: 0 0 0 3px rgba(159, 232, 112, 0.35);
+    }
+    .hint {
+      font-size: 0.6875rem;
+      color: var(--muted);
+      margin: 0.35rem 0 0;
+      line-height: 1.45;
+    }
+    .select { font-family: inherit; cursor: pointer; }
+    .custom-signal-wrap { margin-top: 0.45rem; display: none; }
+    .custom-signal-wrap.visible { display: block; }
+    .checkbox-row {
+      display: flex;
+      gap: 0.5rem;
+      align-items: flex-start;
+      padding: 0.1rem 0;
+    }
+    .checkbox-row input {
+      width: 1.05rem;
+      height: 1.05rem;
+      margin-top: 0.15rem;
+      accent-color: var(--primary-ink);
+      cursor: pointer;
+    }
+    .checkbox-row label {
+      font-size: 0.875rem;
+      color: var(--ink);
+      cursor: pointer;
+      line-height: 1.45;
+    }
+    .checkbox-row .hint-inline {
+      display: block;
+      font-size: 0.6875rem;
+      color: var(--muted);
+      margin-top: 0.15rem;
+    }
+    .divider {
+      height: 1px;
+      background: var(--border);
+      margin: 0.35rem 0 0.6rem;
+      border: none;
+      flex-shrink: 0;
+    }
+    .btn {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      padding: 0.5rem 0.75rem;
+      border-radius: var(--radius-sm);
+      font-size: 0.8125rem;
+      font-weight: 600;
+      font-family: inherit;
+      cursor: pointer;
+      border: 1px solid transparent;
+      transition: background 0.15s, border-color 0.15s, transform 0.05s;
+    }
+    .btn:active { transform: scale(0.98); }
+    .btn:focus-visible {
+      outline: none;
+      box-shadow: 0 0 0 3px rgba(159, 232, 112, 0.45);
+    }
+    .btn-primary {
+      background: var(--primary);
+      color: var(--primary-ink);
+      border-color: var(--primary);
+    }
+    .btn-primary:hover { background: var(--primary-hover); }
+    .btn-secondary {
+      background: transparent;
+      color: var(--ink);
+      border-color: var(--border-strong);
+    }
+    .btn-secondary:hover { background: var(--canvas); }
+    .btn-danger {
+      background: var(--danger-surface);
+      color: var(--danger);
+      border-color: var(--danger-border);
+    }
+    .btn-danger:hover { filter: brightness(0.97); }
+    .fine-print {
+      font-size: 0.6875rem;
+      color: var(--muted);
+      margin: 0.45rem 0 0;
+      line-height: 1.4;
+    }
+    .danger-callout {
+      font-size: 0.6875rem;
+      color: var(--danger);
+      background: var(--danger-surface);
+      border: 1px solid var(--danger-border);
+      border-radius: var(--radius-sm);
+      padding: 0.45rem 0.55rem;
+      margin-top: 0.45rem;
+      line-height: 1.4;
+    }
+    .output-panel {
+      margin: 0;
+      flex: 1;
+      min-height: 5rem;
+      padding: 0.65rem 0.75rem;
+      border-radius: var(--radius-md);
+      border: 1px solid var(--border);
+      background: var(--canvas);
+      font-size: 0.8125rem;
+      line-height: 1.5;
+      white-space: pre-wrap;
+      word-break: break-word;
+      overflow-y: scroll;
+      overflow-x: hidden;
+    }
+    .out-ok { color: var(--success-text); }
+    .out-warn { color: var(--warn-text); }
+    .out-err { color: var(--danger); }
+    @media (max-width: 720px) {
+      html {
+        height: auto;
+        min-height: 100%;
+        overflow-y: scroll;
+        scrollbar-gutter: stable;
+      }
+      body {
+        height: auto;
+        min-height: 100%;
+        overflow-x: hidden;
+        overflow-y: visible;
+      }
+      .wrap {
+        height: auto;
+        max-height: none;
+      }
+      .panel-unified {
+        min-height: min(85vh, 40rem);
+      }
+      .panel-split {
+        grid-template-columns: 1fr;
+      }
+      .col--results {
+        border-left: none;
+        border-top: 1px solid var(--border);
+        min-height: 14rem;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <header class="masthead">
+      <h1 class="page-title" aria-label="portkill"><span class="title-dot" aria-hidden="true">.</span>portkill</h1>
+      <p class="lede">TCP ports on <strong>this machine</strong> \u2014 preview first, then stop only what you mean to.</p>
+    </header>
+
+    <div class="info-prompt" role="note">
+      <span aria-hidden="true">\u{1F512}</span>
+      <div><strong>Local only.</strong> Server on <code>127.0.0.1</code> \u2014 not exposed by portkill.</div>
+    </div>
+
+    <main class="panel-unified">
+      <div class="action-bar">
+        <p class="action-bar-title">Actions</p>
+        <div class="actions">
+          <button type="button" class="btn btn-primary" id="btn-list">Show listening ports</button>
+          <button type="button" class="btn btn-secondary" id="btn-run">Preview</button>
+          <button type="button" class="btn btn-danger" id="btn-kill">Stop</button>
+        </div>
+        <p class="hint">Listening ports needs no input below. Preview / Stop use ports, signal, and dry-run.</p>
+      </div>
+
+      <div class="panel-split">
+        <section class="col col--controls" aria-label="Controls">
+          <div class="field">
+            <p class="section-header">Ports</p>
+            <h2 class="section-title">Targets</h2>
+            <p class="supporting">Spaces, commas, or ranges (e.g. <code>3000-3003</code>).</p>
+            <label class="label" for="ports">Port numbers</label>
+            <textarea id="ports" class="textarea" placeholder="e.g. 3000 8080" aria-describedby="ports-hint"></textarea>
+            <p id="ports-hint" class="hint">Use Show listening ports if unsure what is open.</p>
+          </div>
+
+          <hr class="divider" />
+
+          <div class="field">
+            <p class="section-header">Signal</p>
+            <h2 class="section-title">Stop request</h2>
+            <p class="supporting">Signals are OS messages \u2014 polite shutdown vs. force.</p>
+            <label class="label" for="signal-preset">Signal</label>
+            <select id="signal-preset" class="select" aria-describedby="signal-hint">
+              <option value="SIGTERM">SIGTERM \u2014 polite (recommended)</option>
+              <option value="SIGINT">SIGINT \u2014 like Ctrl+C</option>
+              <option value="SIGKILL">SIGKILL \u2014 cannot be ignored</option>
+              <option value="custom">Custom\u2026</option>
+            </select>
+            <div id="custom-signal-wrap" class="custom-signal-wrap">
+              <label class="label" for="signal-custom">Custom</label>
+              <input type="text" id="signal-custom" class="input" placeholder="SIGUSR1 or 15" autocomplete="off" />
+            </div>
+            <p id="signal-hint" class="hint"><strong>SIGTERM</strong> for a clean exit; <strong>SIGKILL</strong> only if needed.</p>
+          </div>
+
+          <hr class="divider" />
+
+          <div class="field">
+            <div class="checkbox-row">
+              <input type="checkbox" id="dry" checked />
+              <label for="dry">
+                Preview only (dry-run)
+                <span class="hint-inline">No signal sent until you turn this off and choose Stop.</span>
+              </label>
+            </div>
+          </div>
+
+          <hr class="divider" />
+
+          <p class="fine-print">Stop asks for confirmation. Some ports may need <code>sudo</code> in Terminal.</p>
+          <div class="danger-callout" role="note"><strong>SIGKILL</strong> \u2014 possible data loss; last resort.</div>
+        </section>
+
+        <section class="col col--results" aria-label="Results">
+          <p class="section-header">Results</p>
+          <h2 class="section-title">Output</h2>
+          <div id="out" class="output-panel" role="status" aria-live="polite">Ready when you are.</div>
+        </section>
+      </div>
+
+      <footer class="panel-footer">Designed by Burak Boduroglu \xB7 Made with <span class="heart" aria-label="love">\u2665</span></footer>
+    </main>
+  </div>
+  <script>
+(function () {
+  var out = document.getElementById("out");
+  var presetEl = document.getElementById("signal-preset");
+  var customWrap = document.getElementById("custom-signal-wrap");
+  var customEl = document.getElementById("signal-custom");
+
+  function setOut(html) { out.innerHTML = html; }
+  function toggleCustom() {
+    var show = presetEl.value === "custom";
+    customWrap.classList.toggle("visible", show);
+    customEl.disabled = !show;
+  }
+  presetEl.addEventListener("change", toggleCustom);
+  toggleCustom();
+
+  function getSignal() {
+    if (presetEl.value === "custom") {
+      return (customEl.value || "").trim() || "SIGTERM";
+    }
+    return presetEl.value;
+  }
+
+  function tokensFromInput() {
+    var raw = document.getElementById("ports").value.trim();
+    if (!raw) return [];
+    return raw.split(/[\\s,]+/).filter(Boolean);
+  }
+  function escapeHtml(s) {
+    return String(s).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;");
+  }
+  function formatOutcome(o) {
+    switch (o.kind) {
+      case "notFound": return "Port " + o.port + " \u2014 nothing listening";
+      case "killed": return "Port " + o.port + " \u2014 stopped (" + (o.commandName || "unknown") + ", PID " + o.pid + ")";
+      case "dryRunWouldKill":
+        return "Port " + o.port + " \u2014 would stop " + (o.commandName || "unknown") + " (PID " + o.pid + "); preview only";
+      case "permissionDenied": return "Port " + o.port + " \u2014 permission denied (try sudo in Terminal)";
+      case "error": return "Port " + o.port + " \u2014 " + o.message;
+      default: return JSON.stringify(o);
+    }
+  }
+  function outcomeClass(k) {
+    if (k === "killed" || k === "dryRunWouldKill") return "out-ok";
+    if (k === "notFound") return "out-warn";
+    return "out-err";
+  }
+  function apiUrl(path) {
+    return new URL(path, window.location.origin).href;
+  }
+  async function api(path, opts) {
+    var r = await fetch(apiUrl(path), opts);
+    var text = await r.text();
+    var data;
+    try { data = JSON.parse(text); } catch (e) { data = { raw: text }; }
+    if (!r.ok) throw new Error(data.message || data.error || text || String(r.status));
+    return data;
+  }
+  document.getElementById("btn-list").onclick = async function () {
+    setOut("Loading\u2026");
+    try {
+      var data = await api("/api/listeners");
+      if (!data.ok) throw new Error(data.message || "failed");
+      if (!data.rows.length) { setOut("No TCP listeners right now."); return; }
+      var lines = data.rows.map(function (row) {
+        return "Port " + row.port + " \u2014 " + row.commandName + " (PID " + row.pid + ")";
+      });
+      setOut(lines.map(function (l) {
+        return '<span class="' + outcomeClass("killed") + '">' + escapeHtml(l) + "</span>";
+      }).join("<br>"));
+    } catch (e) {
+      setOut('<span class="out-err">' + escapeHtml(String(e.message || e)) + "</span>");
+    }
+  };
+  document.getElementById("btn-run").onclick = async function () {
+    document.getElementById("dry").checked = true;
+    await resolvePorts(false);
+  };
+  document.getElementById("btn-kill").onclick = async function () {
+    var msg = "Send a stop signal to processes on these ports? Unsaved work in those apps may be lost.";
+    if (!confirm(msg)) return;
+    document.getElementById("dry").checked = false;
+    await resolvePorts(true);
+  };
+  async function resolvePorts(forceKill) {
+    var tokens = tokensFromInput();
+    if (!tokens.length) {
+      setOut('<span class="out-err">Add at least one port or range in Targets.</span>');
+      return;
+    }
+    var dryRun = document.getElementById("dry").checked;
+    var signal = getSignal();
+    var force = forceKill === true;
+    setOut("Working\u2026");
+    try {
+      var data = await api("/api/resolve", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tokens: tokens, dryRun: dryRun, force: force, signal: signal }),
+      });
+      if (!data.ok) throw new Error(data.message || "failed");
+      var html = (data.outcomes || []).map(function (o) {
+        return '<span class="' + outcomeClass(o.kind) + '">' + escapeHtml(formatOutcome(o)) + "</span>";
+      }).join("<br>");
+      setOut(html || ("Finished. Exit code " + data.exitCode + "."));
+    } catch (e) {
+      setOut('<span class="out-err">' + escapeHtml(String(e.message || e)) + "</span>");
+    }
+  }
+})();
+  </script>
+</body>
+</html>`;
+}
+
+// src/gui/open-browser.ts
+import { spawn } from "child_process";
+function openBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+    } else if (process.platform === "linux") {
+      spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+    }
+  } catch {
+  }
+}
+
+// src/gui/server.ts
+var HOST = "127.0.0.1";
+var MAX_BODY = 64 * 1024;
+function applyApiCors(req, res) {
+  const origin = req.headers.origin;
+  if (origin) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+  } else {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+  }
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}
+function json(res, req, status, body) {
+  applyApiCors(req, res);
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(payload)
+  });
+  res.end(payload);
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of req) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += buf.length;
+    if (total > MAX_BODY) {
+      throw new Error("request body too large");
+    }
+    chunks.push(buf);
+  }
+  if (chunks.length === 0) return {};
+  const raw = Buffer.concat(chunks).toString("utf8");
+  if (!raw.trim()) return {};
+  return JSON.parse(raw);
+}
+function startGuiServer(opts) {
+  const requestHandler = async (req, res) => {
+    try {
+      const url = new URL(req.url ?? "/", `http://${HOST}`);
+      if (req.method === "OPTIONS" && url.pathname.startsWith("/api/")) {
+        applyApiCors(req, res);
+        res.writeHead(204).end();
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/") {
+        const html = getIndexHtml();
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8",
+          "Content-Length": Buffer.byteLength(html, "utf8")
+        });
+        res.end(html);
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/api/listeners") {
+        const result = await listAllTcpListeners(opts.platform);
+        if (!result.ok) {
+          json(res, req, 200, { ok: false, message: result.message });
+          return;
+        }
+        json(res, req, 200, { ok: true, rows: result.rows });
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/resolve") {
+        let body;
+        try {
+          body = await readJsonBody(req);
+        } catch {
+          json(res, req, 400, { ok: false, message: "invalid JSON body" });
+          return;
+        }
+        if (!body || typeof body !== "object") {
+          json(res, req, 400, { ok: false, message: "expected JSON object" });
+          return;
+        }
+        const b = body;
+        const tokens = b.tokens;
+        if (!Array.isArray(tokens) || !tokens.every((t) => typeof t === "string")) {
+          json(res, req, 400, { ok: false, message: "tokens must be an array of strings" });
+          return;
+        }
+        let ports;
+        try {
+          ports = parsePortArguments(tokens);
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          json(res, req, 400, { ok: false, message: msg });
+          return;
+        }
+        if (ports.length === 0) {
+          json(res, req, 400, { ok: false, message: "no valid ports after parsing" });
+          return;
+        }
+        const dryRun = Boolean(b.dryRun);
+        const force = Boolean(b.force);
+        const signal = typeof b.signal === "string" ? b.signal : "SIGTERM";
+        const { exitCode, outcomes } = await runKill({
+          ports,
+          dryRun,
+          force,
+          verbose: false,
+          signal,
+          platform: opts.platform
+        });
+        json(res, req, 200, {
+          ok: true,
+          exitCode,
+          outcomes
+        });
+        return;
+      }
+      res.writeHead(404).end("not found");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      json(res, req, 500, { ok: false, message: msg });
+    }
+  };
+  const server4 = createServer(requestHandler);
+  return new Promise((resolve, reject) => {
+    server4.once("error", reject);
+    server4.listen(opts.port ?? 0, HOST, () => {
+      server4.off("error", reject);
+      const addr = server4.address();
+      const port = addr && typeof addr === "object" && "port" in addr ? addr.port : 0;
+      const baseUrl = `http://${HOST}:${port}`;
+      const v6 = createServer(requestHandler);
+      let settled = false;
+      const finish = (servers) => {
+        if (settled) return;
+        settled = true;
+        if (opts.openBrowser !== false) {
+          openBrowser(baseUrl);
+        }
+        resolve({ url: baseUrl, servers });
+      };
+      v6.once("error", () => finish([server4]));
+      v6.listen(port, "::1", () => finish([server4, v6]));
+    });
+  });
+}
+function attachGuiShutdown(...servers) {
+  const shutdown = () => {
+    const list = servers.filter(Boolean);
+    if (list.length === 0) {
+      process5.exit(0);
+      return;
+    }
+    let pending = list.length;
+    for (const s of list) {
+      s.close(() => {
+        if (--pending <= 0) process5.exit(0);
+      });
+    }
+  };
+  process5.on("SIGINT", shutdown);
+  process5.on("SIGTERM", shutdown);
+}
+
+// src/utils/platform.ts
+var UnsupportedPlatformError = class extends Error {
+  platform;
+  constructor(platform) {
+    super(`portkill is not supported on this platform (${platform}). Supported: macOS, Linux.`);
+    this.name = "UnsupportedPlatformError";
+    this.platform = platform;
+  }
+};
+function getSupportedPlatform() {
+  const p = process.platform;
+  if (p === "darwin" || p === "linux") return p;
+  throw new UnsupportedPlatformError(p);
+}
+
+// src/index.ts
+function readPackageVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(here, "..", "package.json");
+    const raw = readFileSync(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function main() {
+  const program = new Command();
+  program.name("portkill").description("Kill processes listening on given TCP ports").argument(
+    "[ports...]",
+    "TCP ports and/or ranges (e.g. 3000 8080 3000-3005); 1\u201365535, max 4096 ports per range"
+  ).option("-f, --force", "do not prompt for confirmation", false).option("-n, --dry-run", "show targets only; do not send signals", false).option("-s, --signal <name>", "signal to send (default: SIGTERM)", "SIGTERM").option("-v, --verbose", "verbose stderr logs", false).option("-l, --list", "list all TCP listening ports and processes", false).option("--gui", "open local web UI (127.0.0.1 only)", false).configureHelp({ helpWidth: 88 }).action(async (portsArg, options) => {
+    const list = options.list;
+    const gui = options.gui;
+    if (gui && list) {
+      process6.stderr.write("error: do not combine --gui with --list\n");
+      process6.exitCode = 1;
+      return;
+    }
+    if (gui && portsArg.length > 0) {
+      process6.stderr.write("error: do not pass ports together with --gui\n");
+      process6.exitCode = 1;
+      return;
+    }
+    if (list && portsArg.length > 0) {
+      process6.stderr.write("error: do not pass ports together with --list\n");
+      process6.exitCode = 1;
+      return;
+    }
+    if (list) {
+      let platform2;
+      try {
+        platform2 = getSupportedPlatform();
+      } catch (e) {
+        if (e instanceof UnsupportedPlatformError) {
+          process6.stderr.write(`${e.message}
+`);
+          process6.exitCode = 1;
+          return;
+        }
+        throw e;
+      }
+      const { exitCode: exitCode2, lines: lines2 } = await runList({
+        platform: platform2,
+        verbose: options.verbose
+      });
+      for (const line of lines2) {
+        process6.stdout.write(`${line}
+`);
+      }
+      process6.exitCode = exitCode2;
+      return;
+    }
+    if (gui) {
+      let platform2;
+      try {
+        platform2 = getSupportedPlatform();
+      } catch (e) {
+        if (e instanceof UnsupportedPlatformError) {
+          process6.stderr.write(`${e.message}
+`);
+          process6.exitCode = 1;
+          return;
+        }
+        throw e;
+      }
+      const { url, servers } = await startGuiServer({ platform: platform2 });
+      process6.stdout.write(`portkill GUI: ${url}
+`);
+      process6.stdout.write("Press Ctrl+C to stop.\n");
+      attachGuiShutdown(...servers);
+      return;
+    }
+    if (portsArg.length === 0) {
+      program.help({ error: true });
+      return;
+    }
+    let ports;
+    try {
+      ports = parsePortArguments(portsArg);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process6.stderr.write(`${msg}
+`);
+      process6.exitCode = 1;
+      return;
+    }
+    let platform;
+    try {
+      platform = getSupportedPlatform();
+    } catch (e) {
+      if (e instanceof UnsupportedPlatformError) {
+        process6.stderr.write(`${e.message}
+`);
+        process6.exitCode = 1;
+        return;
+      }
+      throw e;
+    }
+    const { exitCode, lines } = await runKill({
+      ports,
+      dryRun: options.dryRun,
+      force: options.force,
+      verbose: options.verbose,
+      signal: options.signal,
+      platform
+    });
+    for (const line of lines) {
+      process6.stdout.write(`${line}
+`);
+    }
+    process6.exitCode = exitCode;
+  });
+  program.version(readPackageVersion(), "-V, --version", "output version number");
+  await program.parseAsync(process6.argv);
+}
+main().catch((err) => {
+  process6.stderr.write(err instanceof Error ? `${err.message}
+` : `${String(err)}
+`);
+  process6.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map