devenv-inspector 0.2.0 → 0.3.0

package/README.md

@@ -3,10 +3,10 @@
 
   <h1>DevEnv Inspector</h1>
 
-  <p>A unified desktop GUI for inspecting and managing your development runtimes and global packages — no terminal required.</p>
+  <p>A unified desktop GUI for inspecting runtimes, managing global packages, and monitoring active local ports — no terminal required.</p>
 
   <p>
-    <img src="https://img.shields.io/badge/version-0.1.0-5a7af5?style=for-the-badge" alt="Version" />
+    <img src="https://img.shields.io/badge/version-0.3.0-5a7af5?style=for-the-badge" alt="Version" />
     <img src="https://img.shields.io/badge/platform-macOS-lightgrey?style=for-the-badge&logo=apple" alt="Platform" />
     <img src="https://img.shields.io/badge/license-MIT-44c98b?style=for-the-badge" alt="License" />
     <img src="https://img.shields.io/badge/open%20source-%E2%9D%A4-e05454?style=for-the-badge" alt="Open Source" />
@@ -32,7 +32,7 @@
 
 ## What is this?
 
-Developers who work across Python, Node.js, and Conda constantly switch between terminal commands just to see what's installed. DevEnv Inspector puts it all in one window — version badges, a searchable package list, and one-click uninstallation.
+Developers who work across Python, Node.js, and Conda constantly switch between terminal commands just to see what's installed — and what's running. DevEnv Inspector puts it all in one window: version badges, a searchable package list, one-click uninstallation, and a live view of every port in use on your machine.
 
 <div align="center">
   <img src="media/screenshot.png" alt="DevEnv Inspector Screenshot" width="780" />
@@ -42,11 +42,14 @@ Developers who work across Python, Node.js, and Conda constantly switch between
 
 ## Features
 
-- **Runtime detection** — instantly shows installed versions of Python, Conda, and Node.js
-- **Unified package table** — all pip, conda, and npm global packages in one searchable list
+- **Runtime detection** — instantly shows installed versions of Python, Conda, Node.js, npm, Yarn, and pnpm
+- **Unified package table** — all pip, conda, npm, yarn, and pnpm global packages in one searchable list
 - **Safe uninstallation** — confirmation dialog before any package is removed
-- **Filter by manager** — quickly scope the list to pip / conda / npm
-- **Graceful fallbacks** — missing runtimes show "Not Installed" and hide irrelevant packages
+- **Filter by manager** — dynamically shows only the managers that are installed on your machine
+- **Active Ports tab** — see every TCP/UDP port in use: port number, protocol, PID, and process name
+- **Kill process** — terminate any port's process with a single click and a confirmation dialog
+- **Graceful fallbacks** — missing runtimes show "Not Installed" and hide irrelevant filter tabs
+- **Plugin system** — add support for new package managers in a single file, zero changes to core code
 - **No internet required** — everything runs locally against your machine
 
 ---
@@ -63,8 +66,10 @@ npm install -g devenv-inspector-cli
 devenv list                        # show all runtimes
 devenv packages                    # list all global packages
 devenv packages --runtime pip      # filter by manager
+devenv packages --runtime pnpm     # pnpm only
 devenv uninstall numpy --runtime conda
-devenv info python
+devenv info pnpm
+devenv ports                       # show all active local ports
 ```
 
 > Source lives in [`cli/`](./cli) — same repo, zero Electron. Docker support included.
@@ -126,52 +131,135 @@ npm run package
 ```
 
 This builds the source and produces a `.dmg` installer in `dist/`:
-- `DevEnv Inspector-0.1.0-arm64.dmg` — Apple Silicon
-- `DevEnv Inspector-0.1.0.dmg` — Intel
+- `DevEnv Inspector-0.3.0-arm64.dmg` — Apple Silicon
+- `DevEnv Inspector-0.3.0.dmg` — Intel
 
 ---
 
 ## How It Works
 
 ```
-┌─────────────────────────────────────────────┐
-│              Renderer Process               │
-│   React UI — table, filters, dialogs        │
-└──────────────────┬──────────────────────────┘
-                   │  IPC (contextBridge)
-┌──────────────────▼──────────────────────────┐
-│               Main Process                  │
-│  detectors.js  →  python3 / conda / node    │
-│  parsers.js    →  pip / conda / npm --json  │
-│  ipcHandlers.js → uninstall routing         │
-│  shell.js      →  login shell executor      │
-└─────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────┐
+│                    Renderer Process                     │
+│   React UI — runtime cards, Packages tab, Ports tab    │
+│   Tabs derived dynamically from registry metadata       │
+└──────────────────────┬──────────────────────────────────┘
+                       │  IPC (contextBridge)
+┌──────────────────────▼──────────────────────────────────┐
+│                     Main Process                        │
+│  runtimes/builtins.js  →  registerRuntime() × 6        │
+│  registry.js           →  getRegisteredRuntimes()       │
+│  detectors.js          →  registry loop → versions      │
+│  parsers.js            →  registry loop → packages      │
+│  ports.js              →  lsof → TCP/UDP port list      │
+│  ipcHandlers.js        →  uninstall + kill-port routing │
+│  shell.js              →  login shell executor          │
+└─────────────────────────────────────────────────────────┘
 ```
 
 Every command runs through the user's login shell (`zsh -i -l -c`) so that conda, pyenv, nvm, and other shell-managed tools are always found — both in dev mode and in the packaged `.app`.
 
 ---
 
-## Supported Runtimes (v0.1.0)
+## Supported Runtimes (v0.3.0)
 
-| Runtime | Packages | Uninstall |
+| Runtime | Detect | Packages | Uninstall |
+|---|---|---|---|
+| Python | `python3 --version` | `python3 -m pip list --format=json` | `python3 -m pip uninstall -y` |
+| Anaconda | `conda --version` | `conda list --json` | `conda remove -y` |
+| Node.js | `node --version` | — | — |
+| npm | `npm --version` | `npm list -g --depth=0 --json` | `npm uninstall -g` |
+| Yarn | `yarn --version` | `yarn global list --json` | `yarn global remove` |
+| pnpm | `pnpm --version` | `pnpm list -g --json` | `pnpm remove -g` |
+
+---
+
+## Active Local Ports
+
+The **Active Ports** tab gives you an instant overview of every listening port on your machine — the same information as `lsof`, presented without the terminal.
+
+| Column | Description |
+|---|---|
+| **Port** | The open port number |
+| **Protocol** | TCP or UDP |
+| **PID** | Process ID using the port |
+| **Process** | Name of the program / service |
+
+### In the GUI
+
+- Switch to the **Active Ports** tab next to Packages — a live count badge shows how many ports are open
+- Search by port number, process name, or PID
+- Filter by **TCP** / **UDP**
+- Click **Kill** on any row → confirmation dialog → sends `SIGTERM` to that process
+
+### How ports are detected
+
+`lsof -F pcn` is used with structured field output — no text parsing of headers, injection-safe. TCP ports are filtered to `LISTEN` state only. IPv4/IPv6 duplicates are deduplicated automatically.
+
+---
+
+## Plugin System
+
+v0.3.0 ships a runtime registry that makes adding new package managers trivial. Each built-in (pip, conda, npm, yarn, pnpm) is now a self-describing plugin object registered via `registerRuntime()`. The core detectors, parsers, IPC handlers, and renderer UI are all driven by the registry — they contain zero hardcoded manager names.
+
+### Adding a community runtime (e.g. Bun)
+
+Create one file — `src/main/runtimes/bun.js`:
+
+```js
+import { registerRuntime } from '../registry.js'
+import { runInShell } from '../shell.js'
+
+registerRuntime({
+  name:         'bun',
+  label:        'Bun',
+  color:        '#fbf0df',
+  detect:       () => runInShell('bun', ['--version'], { timeout: 10000 }).catch(() => null),
+  parseVersion: (o) => o.trim().replace(/^bun\s+v?/i, ''),
+  list:         async () => { /* parse: bun pm ls --global */ },
+  uninstall:    (pkg) => ['bun', ['remove', '-g', pkg]]
+})
+```
+
+Then add **one import line** in `src/main/index.js`:
+
+```js
+import './runtimes/bun.js'
+```
+
+That's it. The runtime card, filter tab, package listing, and uninstall button all appear automatically — **zero changes to core code**.
+
+### Plugin shape reference
+
+| Field | Type | Description |
 |---|---|---|
-| Python | `python3 -m pip list` | `python3 -m pip uninstall -y` |
-| Anaconda | `conda list --json` | `conda remove -y` |
-| Node.js | `npm list -g --depth=0` | `npm uninstall -g` |
-| Yarn | `yarn global list --json` | `yarn global remove` |
-| pnpm | `pnpm list -g --json` | `pnpm remove -g` |
+| `name` | `string` | Unique key (also used as `manager` in package rows) |
+| `label` | `string` | Display name in UI and CLI |
+| `color` | `string` | Hex color for the manager badge |
+| `detect` | `async () => string \| null` | Returns raw stdout, or `null` if not installed |
+| `parseVersion` | `(output) => string` | Cleans `detect()` output to a version string |
+| `list` | `async () => [{name, version}] \| null` | `null` = no packages for this runtime |
+| `uninstall` | `(pkg) => [cmd, args] \| null` | `null` = uninstall not supported |
 
 ---
 
 ## Roadmap
 
-- [ ] nvm / pyenv support
+### Shipped
+- [x] Python, Conda, Node.js, npm, Yarn, pnpm support
+- [x] Searchable + filterable global package table
+- [x] One-click uninstall with confirmation
+- [x] CLI companion (`devenv-inspector-cli` on npm)
+- [x] Docker support for the CLI
+- [x] **Plugin system** — add any runtime in a single file
+- [x] **Active Local Ports** — live TCP/UDP port viewer with process names and kill support
+
+### Upcoming
+- [ ] nvm / pyenv version manager support
 - [ ] Virtual environment detection
-- [ ] Package update detection
+- [ ] Package update detection (`outdated` view)
 - [ ] Dependency graph visualization
 - [ ] Dark / light mode toggle
-- [ ] Plugin system for new package managers
 - [ ] Windows & Linux support
 
 ---

package/cli/README.md

@@ -1,9 +1,9 @@
 <div align="center">
   <h1>devenv-inspector-cli</h1>
-  <p>Inspect runtimes and manage global packages from your terminal — no GUI required.</p>
+  <p>Inspect runtimes, manage global packages, and monitor active local ports from your terminal — no GUI required.</p>
 
   <p>
-    <img src="https://img.shields.io/badge/version-0.1.0-5a7af5?style=for-the-badge" alt="Version" />
+    <img src="https://img.shields.io/badge/version-0.3.0-5a7af5?style=for-the-badge" alt="Version" />
     <img src="https://img.shields.io/badge/platform-macOS-lightgrey?style=for-the-badge&logo=apple" alt="Platform" />
     <img src="https://img.shields.io/badge/license-MIT-44c98b?style=for-the-badge" alt="License" />
     <img src="https://img.shields.io/npm/v/devenv-inspector-cli?style=for-the-badge&logo=npm&color=cc3534" alt="npm" />
@@ -31,6 +31,7 @@ No Node.js or Python required — just Docker:
 docker run --rm ghcr.io/ali-aldahmani/devenv-inspector-cli list
 docker run --rm ghcr.io/ali-aldahmani/devenv-inspector-cli packages
 docker run --rm ghcr.io/ali-aldahmani/devenv-inspector-cli info python
+docker run --rm ghcr.io/ali-aldahmani/devenv-inspector-cli ports
 
 # Or build locally from source
 git clone https://github.com/Ali-Aldahmani/devenv-inspector.git
@@ -57,6 +58,8 @@ $ devenv list
   Conda       26.1.0
   Node.js     24.13.0
   npm         11.6.2
+  Yarn        1.22.22
+  pnpm        9.15.4
 ```
 
 ---
@@ -69,6 +72,8 @@ devenv packages                  # all packages
 devenv packages --runtime pip    # pip only
 devenv packages --runtime conda  # conda only
 devenv packages --runtime npm    # npm only
+devenv packages --runtime yarn   # yarn only
+devenv packages --runtime pnpm   # pnpm only
 ```
 
 ```
@@ -93,6 +98,8 @@ Uninstall a package with a confirmation prompt.
 devenv uninstall requests --runtime pip
 devenv uninstall numpy --runtime conda
 devenv uninstall electron --runtime npm
+devenv uninstall create-react-app --runtime yarn
+devenv uninstall typescript --runtime pnpm
 ```
 
 ```
@@ -112,6 +119,8 @@ devenv info python
 devenv info conda
 devenv info node
 devenv info npm
+devenv info yarn
+devenv info pnpm
 ```
 
 ```
@@ -126,12 +135,102 @@ $ devenv info python
 
 ---
 
+### `devenv ports`
+Show all active local listening ports (TCP + UDP) with their process details.
+
+```
+$ devenv ports
+
+  DevEnv Inspector — Active Local Ports
+
+  ┌────────┬──────────┬───────┬────────────┐
+  │ Port   │ Protocol │ PID   │ Process    │
+  ├────────┼──────────┼───────┼────────────┤
+  │ 3000   │ TCP      │ 1234  │ node       │
+  │ 5432   │ TCP      │ 2345  │ postgres   │
+  │ 8000   │ TCP      │ 3456  │ python3    │
+  │ 8080   │ TCP      │ 4567  │ node       │
+  └────────┴──────────┴───────┴────────────┘
+
+  4 active ports
+```
+
+TCP ports are colored **blue**, UDP ports **orange**. Only `LISTEN` state TCP sockets and bound UDP sockets are shown — established connections are excluded.
+
+---
+
 ## How It Works
 
 All commands run through your login shell (`zsh -i -l -c`) — the same approach as the GUI app — so conda, pyenv, nvm, and other shell-managed tools are always found.
 
 Package names are validated against `/^[a-zA-Z0-9._\-@/]+$/` before any shell call to prevent injection.
 
+Port detection uses `lsof -F pcn` with structured field output — no fragile header parsing. IPv4/IPv6 duplicates are deduplicated automatically.
+
+Runtimes are powered by a **plugin registry** — each manager is a self-describing object registered via `registerRuntime()`. The CLI commands contain zero hardcoded manager names; everything is derived from the registry at runtime.
+
+---
+
+## Plugin System
+
+Adding support for a new package manager requires **one file** and **one import line**.
+
+Create `cli/src/runtimes/bun.js`:
+
+```js
+import { registerRuntime } from '../registry.js'
+import { runInShell } from '../shell.js'
+
+registerRuntime({
+  name:         'bun',
+  label:        'Bun',
+  color:        '#fbf0df',
+  detect:       () => runInShell('bun', ['--version'], { timeout: 10000 }).catch(() => null),
+  parseVersion: (o) => o.trim().replace(/^bun\s+v?/i, ''),
+  list:         async () => { /* parse: bun pm ls --global */ },
+  uninstall:    (pkg) => ['bun', ['remove', '-g', pkg]]
+})
+```
+
+Then add one line in `cli/bin/devenv.js`:
+
+```js
+import '../src/runtimes/bun.js'
+```
+
+Bun immediately appears in `devenv list`, `devenv packages --runtime bun`, `devenv uninstall`, and `devenv info bun` — **zero changes to CLI command files**.
+
+### Plugin shape reference
+
+| Field | Type | Description |
+|---|---|---|
+| `name` | `string` | Unique key used as `--runtime` value |
+| `label` | `string` | Display name in output |
+| `color` | `string` | Hex color for colored output |
+| `detect` | `async () => string \| null` | Returns raw stdout, or `null` if not installed |
+| `parseVersion` | `(output) => string` | Cleans `detect()` output to a version string |
+| `list` | `async () => [{name, version}] \| null` | `null` = no packages for this runtime |
+| `uninstall` | `(pkg) => [cmd, args] \| null` | `null` = uninstall not supported |
+
+---
+
+## Roadmap
+
+### Shipped
+- [x] Python, Conda, Node.js, npm, Yarn, pnpm support
+- [x] Colored, tabular package output with `cli-table3`
+- [x] Confirmation prompt before uninstall
+- [x] `devenv info` command for per-runtime details
+- [x] Docker support
+- [x] **Plugin system** — add any runtime in a single file
+- [x] **`devenv ports`** — active TCP/UDP port viewer with process names
+
+### Upcoming
+- [ ] nvm / pyenv version manager support
+- [ ] `devenv packages --outdated` — highlight packages with available updates
+- [ ] JSON output flag (`--json`) for scripting
+- [ ] Windows & Linux support
+
 ---
 
 ## License

package/cli/bin/devenv.js

@@ -1,16 +1,18 @@
 #!/usr/bin/env node
+import '../src/runtimes/builtins.js'
 import { Command } from 'commander'
 import { listCommand } from '../src/commands/list.js'
 import { packagesCommand } from '../src/commands/packages.js'
 import { uninstallCommand } from '../src/commands/uninstall.js'
 import { infoCommand } from '../src/commands/info.js'
+import { portsCommand } from '../src/commands/ports.js'
 
 const program = new Command()
 
 program
   .name('devenv')
   .description('Inspect and manage your development runtimes and global packages')
-  .version('0.1.0')
+  .version('0.3.0')
 
 program
   .command('list')
@@ -34,4 +36,9 @@ program
   .description('Show detailed info for a runtime (python, conda, node, npm)')
   .action(infoCommand)
 
+program
+  .command('ports')
+  .description('Show all active local listening ports and their processes')
+  .action(portsCommand)
+
 await program.parseAsync(process.argv)

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devenv-inspector-cli",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "CLI companion to DevEnv Inspector — inspect runtimes and manage global packages from your terminal",
   "type": "module",
   "bin": {

package/cli/src/commands/info.js

@@ -1,51 +1,44 @@
 import chalk from 'chalk'
 import { detectRuntimes } from '../detectors.js'
 import { getAllPackages } from '../parsers.js'
-
-const RUNTIME_META = {
-  python: { label: 'Python',  manager: 'pip',   packageLabel: 'pip packages' },
-  conda:  { label: 'Conda',   manager: 'conda', packageLabel: 'conda packages' },
-  node:   { label: 'Node.js', manager: null,    packageLabel: null },
-  npm:    { label: 'npm',     manager: 'npm',   packageLabel: 'global npm packages' },
-  yarn:   { label: 'Yarn',    manager: 'yarn',  packageLabel: 'global yarn packages' },
-  pnpm:   { label: 'pnpm',    manager: 'pnpm',  packageLabel: 'global pnpm packages' }
-}
+import { getRegisteredRuntimes, getRuntime } from '../registry.js'
 
 export async function infoCommand(runtime) {
   const key = runtime.toLowerCase()
-  const meta = RUNTIME_META[key]
+  const rt  = getRuntime(key)
 
-  if (!meta) {
-    console.error(chalk.red(`\n  Unknown runtime "${runtime}". Valid values: python, conda, node, npm, yarn, pnpm\n`))
+  if (!rt) {
+    const valid = getRegisteredRuntimes().map((r) => r.name).join(', ')
+    console.error(chalk.red(`\n  Unknown runtime "${runtime}". Valid values: ${valid}\n`))
     process.exit(1)
   }
 
-  if (process.stdout.isTTY) process.stdout.write(`  Loading info for ${meta.label}...`)
+  if (process.stdout.isTTY) process.stdout.write(`  Loading info for ${rt.label}...`)
 
   const runtimes = await detectRuntimes()
 
   if (process.stdout.isTTY) process.stdout.write('\r' + ' '.repeat(40) + '\r')
 
-  const rt = runtimes[key]
+  const info = runtimes[key]
 
-  console.log(chalk.bold(`\n  ${meta.label}\n`))
-  console.log(`  Status   ${rt?.installed ? chalk.green('Installed') : chalk.dim('Not Installed')}`)
+  console.log(chalk.bold(`\n  ${rt.label}\n`))
+  console.log(`  Status   ${info?.installed ? chalk.green('Installed') : chalk.dim('Not Installed')}`)
 
-  if (!rt?.installed) {
+  if (!info?.installed) {
     console.log()
     return
   }
 
-  console.log(`  Version  ${chalk.cyan(rt.version)}`)
+  console.log(`  Version  ${chalk.cyan(info.version)}`)
 
-  // Show package count if this runtime has packages
-  if (meta.manager) {
+  // Show package count if this runtime supports package listing
+  if (rt.list) {
     if (process.stdout.isTTY) process.stdout.write('  Counting packages...')
     const allPkgs = await getAllPackages(runtimes)
     if (process.stdout.isTTY) process.stdout.write('\r' + ' '.repeat(30) + '\r')
 
-    const count = allPkgs.filter((p) => p.manager === meta.manager).length
-    console.log(`  Packages ${chalk.yellow(count)} ${meta.packageLabel}`)
+    const count = allPkgs.filter((p) => p.manager === key).length
+    console.log(`  Packages ${chalk.yellow(count)} global ${rt.label} packages`)
   }
 
   console.log()

package/cli/src/commands/list.js

@@ -1,13 +1,6 @@
 import chalk from 'chalk'
 import { detectRuntimes } from '../detectors.js'
 
-const RUNTIMES = [
-  { key: 'python', label: 'Python' },
-  { key: 'conda',  label: 'Conda' },
-  { key: 'node',   label: 'Node.js' },
-  { key: 'npm',    label: 'npm' }
-]
-
 export async function listCommand() {
   console.log(chalk.bold('\n  DevEnv Inspector — Runtimes\n'))
 
@@ -18,11 +11,10 @@ export async function listCommand() {
 
   if (spinner) process.stdout.write('\r' + ' '.repeat(30) + '\r')
 
-  for (const { key, label } of RUNTIMES) {
-    const rt = runtimes[key]
-    const name = chalk.white.bold(label.padEnd(10))
-    if (rt?.installed) {
-      console.log(`  ${name}  ${chalk.green(rt.version)}`)
+  for (const [, info] of Object.entries(runtimes)) {
+    const name = chalk.white.bold(info.label.padEnd(10))
+    if (info.installed) {
+      console.log(`  ${name}  ${chalk.green(info.version)}`)
     } else {
       console.log(`  ${name}  ${chalk.dim('Not Installed')}`)
     }

package/cli/src/commands/packages.js

@@ -2,22 +2,15 @@ import chalk from 'chalk'
 import Table from 'cli-table3'
 import { detectRuntimes } from '../detectors.js'
 import { getAllPackages } from '../parsers.js'
-
-const VALID_RUNTIMES = ['pip', 'conda', 'npm', 'yarn', 'pnpm']
-
-const MANAGER_COLORS = {
-  pip:   (s) => chalk.hex('#5a7af5')(s),
-  conda: (s) => chalk.hex('#44c98b')(s),
-  npm:   (s) => chalk.hex('#e05454')(s),
-  yarn:  (s) => chalk.hex('#2c8ebb')(s),
-  pnpm:  (s) => chalk.hex('#f69220')(s)
-}
+import { getRegisteredRuntimes, getRuntime } from '../registry.js'
 
 export async function packagesCommand(options) {
   const filter = options.runtime?.toLowerCase()
 
-  if (filter && !VALID_RUNTIMES.includes(filter)) {
-    console.error(chalk.red(`\n  Unknown runtime "${filter}". Valid values: pip, conda, npm, yarn, pnpm\n`))
+  const validRuntimes = getRegisteredRuntimes().filter((rt) => rt.list).map((rt) => rt.name)
+
+  if (filter && !validRuntimes.includes(filter)) {
+    console.error(chalk.red(`\n  Unknown runtime "${filter}". Valid values: ${validRuntimes.join(', ')}\n`))
     process.exit(1)
   }
 
@@ -54,7 +47,8 @@ export async function packagesCommand(options) {
   })
 
   for (const pkg of packages) {
-    const colorFn = MANAGER_COLORS[pkg.manager] || ((s) => s)
+    const color  = getRuntime(pkg.manager)?.color ?? '#ffffff'
+    const colorFn = (s) => chalk.hex(color)(s)
     table.push([
       pkg.name,
       chalk.dim(pkg.version),

package/cli/src/commands/ports.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk'
+import Table from 'cli-table3'
+import { getActivePorts } from '../ports.js'
+
+export async function portsCommand() {
+  console.log(chalk.bold('\n  DevEnv Inspector — Active Local Ports\n'))
+
+  const spinner = process.stdout.isTTY
+  if (spinner) process.stdout.write('  Scanning ports...')
+
+  const ports = await getActivePorts()
+
+  if (spinner) process.stdout.write('\r' + ' '.repeat(30) + '\r')
+
+  if (ports.length === 0) {
+    console.log(chalk.dim('  No active listening ports found.\n'))
+    return
+  }
+
+  const table = new Table({
+    head: [
+      chalk.white.bold('Port'),
+      chalk.white.bold('Protocol'),
+      chalk.white.bold('PID'),
+      chalk.white.bold('Process')
+    ],
+    style: { head: [], border: [] },
+    colWidths: [10, 12, 10, 30]
+  })
+
+  for (const p of ports) {
+    const proto =
+      p.protocol === 'TCP'
+        ? chalk.hex('#4b9eff')(p.protocol)
+        : chalk.hex('#f69220')(p.protocol)
+
+    table.push([
+      chalk.white.bold(String(p.port)),
+      proto,
+      chalk.dim(String(p.pid)),
+      chalk.white(p.process)
+    ])
+  }
+
+  console.log(table.toString())
+  console.log(chalk.dim(`\n  ${ports.length} active port${ports.length !== 1 ? 's' : ''}\n`))
+}

package/cli/src/commands/uninstall.js

@@ -1,24 +1,16 @@
 import chalk from 'chalk'
-import { createRequire } from 'module'
 import { runInShell } from '../shell.js'
+import { getRegisteredRuntimes, getRuntime } from '../registry.js'
 
 const PACKAGE_NAME_RE = /^[a-zA-Z0-9._\-@/]+$/
 
-const VALID_MANAGERS = ['pip', 'conda', 'npm', 'yarn', 'pnpm']
-
-const UNINSTALL_COMMANDS = {
-  pip:   ['python3', ['-m', 'pip', 'uninstall', '-y']],
-  conda: ['conda',   ['remove', '-y']],
-  npm:   ['npm',     ['uninstall', '-g']],
-  yarn:  ['yarn',    ['global', 'remove']],
-  pnpm:  ['pnpm',    ['remove', '-g']]
-}
-
 export async function uninstallCommand(pkg, options) {
   const manager = options.runtime?.toLowerCase()
 
-  if (!VALID_MANAGERS.includes(manager)) {
-    console.error(chalk.red(`\n  Unknown runtime "${manager}". Valid values: pip, conda, npm, yarn, pnpm\n`))
+  const validManagers = getRegisteredRuntimes().filter((rt) => rt.uninstall).map((rt) => rt.name)
+
+  if (!validManagers.includes(manager)) {
+    console.error(chalk.red(`\n  Unknown runtime "${manager}". Valid values: ${validManagers.join(', ')}\n`))
     process.exit(1)
   }
 
@@ -46,8 +38,7 @@ export async function uninstallCommand(pkg, options) {
 
   console.log(chalk.dim(`\n  Running ${manager} uninstall ${pkg}...`))
 
-  const [cmd, baseArgs] = UNINSTALL_COMMANDS[manager]
-  const args = [...baseArgs, pkg]
+  const [cmd, args] = getRuntime(manager).uninstall(pkg)
 
   try {
     await runInShell(cmd, args, { timeout: 60000 })