Netcheck nasıl kurulur?

Bu sayfadan Cursor, Claude Desktop, Claude Code veya VS Code için stdio yapılandırmasını kopyalayın. PlugMCP proxy'sini değil, yayıncının kurulumunu kullanır.

Netcheck için API anahtarı gerekiyor mu?

Bu kayıtta gerekli bir ortam değişkeni listelenmiyor.

Netcheck hangi aktarımı kullanıyor?

Netcheck yerel olarak stdio üzerinden çalışır.

Netcheck MCP sunucusu | PlugMCP

# Install pipx if you don't have it
python3 -m pip install --user pipx
python3 -m pipx ensurepath          # adds ~/.local/bin to PATH (one-time)

# Then install netcheck
pipx install netcheckx

pip install netcheckx

netcheck-setup        # auto-adds ~/.local/bin to ~/.bashrc, ~/.zshrc, ~/.profile
source ~/.bashrc      # reload shell
netcheck --help       # done ✅

sudo snap install netcheck
sudo snap connect netcheck:network-observe   # enables ping & interfaces

sudo dpkg -i netcheck_2.5.0_amd64.deb

choco install netcheck

sudo installer -pkg netcheck-2.5.0.pkg -target /

git clone https://github.com/farman20ali/netcheck.git
cd netcheck
sudo bash packaging/linux/install.sh

git clone https://github.com/farman20ali/netcheck.git
cd netcheck
pip install -e ".[dev]"
python3 -m netcheck --help

Subcommand	Description	Example
`tcp`	TCP port reachability (ranges, CIDR, IP ranges)	`netcheck tcp google.com 80,443`
`dns`	DNS A/AAAA resolution + CNAME aliases	`netcheck dns github.com`
`http`	HTTP/HTTPS status, size, latency, redirects	`netcheck http https://google.com`
`ssl`	SSL certificate + TLS version/cipher/fingerprint	`netcheck ssl google.com -V`
`ping`	ICMP ping with min/avg/max RTT stats; IP ranges run concurrently	`netcheck ping 8.8.8.8`
`interfaces`	Active network interfaces + optional public IP (`--public`)	`netcheck interfaces --all --public`
`ports`	Local listening sockets with process/PID (Docker-aware)	`netcheck ports -f json`
`traceroute`	Hop-by-hop network path trace	`netcheck traceroute 8.8.8.8 -m 20`
`scan`	Concurrent TCP port scanner with service names	`netcheck scan 192.168.1.1 --ports 1-1024`
`whois`	RDAP/WHOIS domain or IP registration lookup	`netcheck whois google.com`
`udp`	UDP stateless port checker (interprets ICMP unreachable as CLOSED)	`netcheck udp 8.8.8.8 53`
`mtr`	MTR-style combined ping + traceroute latency trace	`netcheck mtr google.com`
`preset`	Expand a preconfigured list of hosts to check	`netcheck preset aws`

netcheck tcp google.com 443 --watch --interval 2    # Refresh every 2s
netcheck http https://api.example.com -w -i 5        # Watch HTTP every 5s
netcheck dns github.com -w                           # Watch DNS (default 2s interval)

netcheck http https://api.example.com \
  --method POST \
  -H "Authorization: Bearer token123" \
  -H "Accept: application/json" \
  --auth user:pass

Flag	Description
`-X, --method`	HTTP method: `GET` (default), `HEAD`, `POST`, `PUT`, `DELETE`, `PATCH`
`-H, --header`	Custom header `Key: Value` (repeatable)
`--auth`	Basic auth `user:pass`

netcheck interfaces                   # Show active interfaces only
netcheck interfaces --all             # Show all interfaces (including inactive)
netcheck interfaces --public          # Also fetch and display public WAN IP
netcheck --my-ip --public            # Legacy flag with public IP

netcheck tcp 192.168.1.1-50 22 --show success    # Only successful connections
netcheck tcp 10.0.0.0/24 443 --show fail         # Only failures
netcheck -q 192.168.1.1 80,443 --show success    # Legacy quick-mode filtering

Flag	Default	Description
`-t, --timeout`	`5`	Connection timeout in seconds
`-j, --jobs`	`10`	Concurrent thread pool size
`-f, --format`	`text`	Output format: `text`, `json`, `csv`, `xml`
`--json`	—	JSON output shorthand (alias for `-f json`)
`--show`	`all`	Filter results: `all`, `success`, or `fail` (for `tcp`/`-q`)
`--public`	—	Fetch and display public IP (for `interfaces`/`--my-ip`)
`--retry`	`1`	Number of connection attempts
`--retry-delay`	`1`	Delay between retries (seconds)
`-V, --verbose`	—	Show extended details (headers, SANs, cipher info)
`--no-color`	—	Disable ANSI color output
`-w, --watch`	—	Enable watch/loop mode
`-i, --interval`	`2.0`	Watch refresh interval in seconds
`--alert`	—	Comma-separated alert channels: `email`, `slack`, `webhook`, `desktop`
`--alert-on`	`any`	Which transitions fire alerts: `any`, `down`, `up`
`--alert-cooldown`	`60`	Seconds between repeated alerts per direction
`-v, --version`	—	Print version and exit

Variable	Effect
`NETCHECK_TIMEOUT`	Override default connection timeout (float)
`NETCHECK_MAX_WORKERS`	Override default thread pool size (integer)
`NO_COLOR`	Disable ANSI color output (standard, https://no-color.org/)
`NETCHECK_NO_COLOR`	Alternative for disabling color

NETCHECK_TIMEOUT=10 NETCHECK_MAX_WORKERS=50 netcheck scan 192.168.1.1
NO_COLOR=1 netcheck ssl google.com -f json

Legacy	Equivalent subcommand
`-q, --quick <host> <port>`	`netcheck tcp`
`-d, --dns <host>`	`netcheck dns`
`-p, --ping <host>`	`netcheck ping` (supports IP ranges, runs concurrently)
`-s, --status <url>`	`netcheck http`
`--cert <host>`	`netcheck ssl`
`--my-ip, -ip`	`netcheck interfaces`
`--public`	Adds public IP display (works with `-ip` and `interfaces`)
`--json`	JSON output shorthand (works with `-q` and `tcp`)
`--show all\|success\|fail`	Result filter (works with `-q` and `tcp`)

netcheck traceroute google.com             # Full path
netcheck traceroute 8.8.8.8 -m 15        # Limit to 15 hops
netcheck traceroute github.com -f json    # JSON output

netcheck scan 192.168.1.1                  # Scan ~44 common ports
netcheck scan google.com --ports 80,443,8080
netcheck scan 10.0.0.1 --ports 1-1024 --jobs 100

netcheck whois google.com      # Domain registrar + creation date
netcheck whois 8.8.8.8         # IP network block + organization

netcheck --mcp
# or
python3 -m netcheck.mcp.server

{
  "mcpServers": {
    "netcheck": {
      "command": "python3",
      "args": ["-m", "netcheck.mcp.server"],
      "env": { "PYTHONPATH": "/path/to/netcheck" }
    }
  }
}

Tool	Description
`check_tcp_connectivity`	TCP port reachability
`dns_lookup`	DNS A/AAAA resolution
`check_http_status`	HTTP response check
`check_ssl_certificate`	SSL certificate validation
`ping_host`	ICMP ping
`get_network_interfaces`	List local interfaces
`get_public_ip`	Get public IP
`traceroute`	Trace network path
`scan_ports`	TCP port scanner
`whois_lookup`	Domain/IP registration

packaging/
├── chocolatey/        ← Windows Chocolatey (.nupkg)
│   └── tools/
├── linux/             ← install.sh / uninstall.sh / netcheck.1 / completions
├── macos/             ← macOS .pkg scripts
├── snap/              ← snapcraft.yaml template
└── windows/           ← NSIS installer script (.nsi)

# Check available tools on this machine
python3 build_packages.py --check

# Sync a new version across all config files
python3 build_packages.py --sync-version 2.3.0

# Build all packages for the current OS
python3 build_packages.py --all

# Individual targets
python3 build_packages.py --pypi      # wheel + sdist
python3 build_packages.py --deb       # Debian .deb
python3 build_packages.py --snap      # Snap .snap
python3 build_packages.py --win       # Windows .exe + NSIS + Chocolatey
python3 build_packages.py --mac       # macOS binary + .pkg

# System-wide (requires root)
sudo cp packaging/linux/netcheck.bash-completion /etc/bash_completion.d/netcheck

# Per-user
mkdir -p ~/.local/share/bash-completion/completions
cp packaging/linux/netcheck.bash-completion ~/.local/share/bash-completion/completions/netcheck

mkdir -p ~/.zsh/completions
cp packaging/linux/netcheck.zsh-completion ~/.zsh/completions/_netcheck
# Add to ~/.zshrc:
echo 'fpath=(~/.zsh/completions $fpath)' >> ~/.zshrc
echo 'autoload -U compinit && compinit' >> ~/.zshrc

netcheck config init          # Run interactive wizard to generate config
netcheck config show          # Print current configuration + OS keychain status
netcheck config path          # Print path to config.yaml file
netcheck config edit          # Open config.yaml in your local $EDITOR
netcheck config purge         # Delete config.yaml AND wipe all keychain secrets

netcheck config set-password email      # SMTP app-password
netcheck config set-password smtp_user  # SMTP sender address
netcheck config set-password smtp_to    # SMTP recipient address(es)
netcheck config set-password slack      # Slack incoming webhook URL
netcheck config set-password webhook    # Generic webhook bearer token
netcheck config clear-password email    # Remove a specific keychain entry

netcheck config test-alert email      # Send a real test email now
netcheck config test-alert slack      # Post a test Slack message now
netcheck config test-alert desktop    # Trigger a test desktop notification
netcheck config test-alert webhook    # POST a test webhook payload

Flag	Default	Description
`--alert`	—	Comma-separated channels: `email`, `slack`, `webhook`, `desktop`
`--alert-on`	`any`	Which transitions fire alerts: `any`, `down`, `up`
`--alert-cooldown`	`60`	Minimum seconds between alerts per direction

# Alert via email and Slack on any TCP state change
netcheck tcp api.example.com 443 -w --alert email,slack

# Only alert when a target goes DOWN (suppress UP/recovery alerts)
netcheck tcp api.example.com 443 -w --alert slack --alert-on down

# Alert on recovery only, via desktop notification
netcheck http https://api.example.com -w --alert desktop --alert-on up

# Alert via desktop notifications on DNS changes, 5-minute cooldown
netcheck dns google.com -w --alert desktop --alert-cooldown 300

Run the interactive config wizard and configure your alerting channels (e.g., Slack Webhook or Desktop):
```
netcheck config init
```
In Terminal A, start watching a local port with alerts enabled:
```
netcheck tcp localhost 9999 -w --alert slack,desktop --interval 2
```
(NetCheck initially records the baseline state silently.)
In Terminal B, simulate a service going UP by starting a quick local listener:
- Linux/macOS: nc -lk 9999
- Windows (PowerShell):
```
$listener = [System.Net.Sockets.TcpListener]9999; $listener.Start()
```
NetCheck will register localhost:9999 as UP.
Simulate a service going DOWN by killing the listener in Terminal B (Ctrl+C or $listener.Stop()). NetCheck will detect the state change and immediately trigger a DOWN alert to Slack and Desktop:

❌ Alert: localhost:9999 is DOWN (Connection refused)
Restart the listener in Terminal B. NetCheck will detect the recovery and emit a RECOVERED alert:

✅ Alert: localhost:9999 is back UP

# Monitor hosts from a file and serve metrics on port 9090
netcheck serve --metrics --port 9090 hosts.txt

Create a targets.txt file containing your endpoints:
```
google.com:443
github.com:443
127.0.0.1:80
```

Start the NetCheck daemon:

netcheck serve --metrics --port 9090 targets.txt --interval 10

Verify that the metrics endpoint is outputting valid text format:
```
curl http://localhost:9090/metrics
```

Add the job to your prometheus.yml configuration:

scrape_configs:
  - job_name: 'netcheck'
    scrape_interval: 10s
    static_configs:
      - targets: ['localhost:9090']

You can now build Grafana dashboards or Alertmanager rules based on the netcheck_up metric:

# Alertmanager rule example
groups:
  - name: netcheck_alerts
    rules:
      - alert: EndpointDown
        expr: netcheck_up == 0
        for: 1m
        labels:
          severity: page
        annotations:
          summary: "Endpoint {{ $labels.target }} is offline"

# Check if a TCP port is open — fail the step if not
netcheck tcp prod.example.com 443 -f json | python3 -c \
  "import sys, json; d=json.load(sys.stdin); sys.exit(0 if d['results'][0]['status']=='success' else 1)"

# Extract DNS IPs with jq
netcheck dns api.example.com -f json | jq '.ips[]'

# List open ports as JSON array
netcheck scan 192.168.1.1 --ports 1-1024 -f json | jq '.open_ports[] | {port, service}'

# Get SSL days-until-expiry, alert if < 30
netcheck ssl prod.example.com -f json | jq -e '.days_until_expiry > 30'

# Traceroute hop count for latency monitoring
netcheck traceroute 8.8.8.8 -f json | jq '.hops | length'

# Listening ports as CSV for spreadsheet import
netcheck ports -f csv > listening_ports.csv

# Use NO_COLOR to suppress ANSI in logs
NO_COLOR=1 netcheck tcp prod.example.com 443

# Override timeout and workers for fast CI checks
NETCHECK_TIMEOUT=3 NETCHECK_MAX_WORKERS=50 netcheck scan 10.0.0.1 --ports 80,443,8080 -f json

Code	Meaning
`0`	All checks succeeded
`1`	One or more checks failed
`2`	Argument / usage error

# Using Make
make test

# Using pytest directly
PYTHONPATH=. python3 -m pytest tests/ -v

# With coverage
PYTHONPATH=. python3 -m pytest tests/ --cov=netcheck --cov-report=term-missing

netcheck/
├── netcheck/                  ← Python package
│   ├── __init__.py            ← version string
│   ├── __main__.py            ← python3 -m netcheck entry point
│   ├── cli.py                 ← CLI argument parsing & dispatch
│   ├── mcp/                   ← MCP server + tool definitions
│   ├── modules/               ← dns, tcp, http, ssl, ping, interfaces,
│   │                             traceroute, port_scanner, whois
│   └── utils/                 ← formatters, retry, concurrency, services
├── packaging/                 ← Platform packaging templates
│   ├── chocolatey/
│   ├── linux/                 ← install.sh, netcheck.1, bash/zsh completions
│   ├── macos/
│   ├── snap/
│   └── windows/
├── tests/                     ← pytest test suite (305 tests)
├── docs/                      ← Guides and release notes
├── .github/workflows/         ← CI (ci.yml) + Release (release.yml)
├── build_packages.py          ← Build orchestration script
├── pyproject.toml             ← Package metadata & build config
├── python-requirements.txt    ← Local dev setup shortcut
└── Makefile                   ← make install / test / clean

Exit Code	Constant	Meaning
`0`	`EXIT_OK`	All network checks passed successfully
`1`	`EXIT_FAIL`	One or more checks failed or targets were unreachable
`2`	`EXIT_BAD_ARGS`	Invalid arguments, unsupported flags, or empty target list
`3`	`EXIT_ERROR`	Unexpected runtime error
`130`	`EXIT_INTERRUPT`	Interrupted by user via Ctrl+C / SIGINT (POSIX standard `128 + 2`)

Netcheck

Q: Netcheck en son ne zaman kontrol edildi?

Son kontrol: 2026-10-28. Comprehensive cross-platform network diagnostics CLI & MCP server (TCP, DNS, HTTP, SSL, Traceroute, Port Scan).

farman20ali3 yıldız

Comprehensive cross-platform network diagnostics CLI & MCP server (TCP, DNS, HTTP, SSL, Traceroute, Port Scan).

Bash Bash Script Cli Connectivity Checker

Kur PlugMCP’de çalıştırBu sunucuyu sahiplen

GitHub

PlugMCP’de çalıştır

1# Netcheck

README.mdMCP sunucusu

Aktarım: stdio
Durum: Yerel

Bu sunucuyu ekle

Host a copy with our keys and logs.

Sunucu bilgileri

Dokümantasyon

Network Connectivity Checker (netcheck)

🚀 Key Features

📦 Installation

Option 1: pipx — Linux / macOS ✅ Recommended

Option 1b: pip — Linux / macOS (alternative)

Option 2: Snap Store (Linux)

Option 3: Debian package (.deb)

Option 4: Chocolatey (Windows)

Option 5: macOS .pkg

Option 6: Linux installer (with shell completions + man page)

Option 7: Developer / local run (no install)

🛠️ CLI Reference

Subcommands

Watch Mode

HTTP Subcommand Options

Interfaces / Public IP Options

Output Filtering (--show)

Global Flags

Environment Variables

Legacy Flags (kept for backward compatibility)

🔍 Traceroute & Port Scan

Traceroute

Port Scan

WHOIS / RDAP Lookup

🤖 MCP Server

🏗️ Building Packages

Common build commands

🔧 Shell Completions

Bash

Zsh

⚙️ Alerting, Config & Prometheus (serve)

1. Configuration Manager

2. Alerting Engine

🧪 How to Test Alerts Locally

3. Prometheus Metrics Exporter (serve mode)

📡 How to Integrate with Prometheus

⚙️ CI/CD Integration

Exit Codes

🧪 Running Tests

📁 Repository Structure

🚦 Exit Codes

🛡️ License

Araçlar

Sorular

Netcheck nasıl kurulur?

Netcheck için API anahtarı gerekiyor mu?

Netcheck hangi aktarımı kullanıyor?

Netcheck en son ne zaman kontrol edildi?

Network Connectivity Checker (`netcheck`)

Option 3: Debian package (`.deb`)

Option 5: macOS `.pkg`

Output Filtering (`--show`)

⚙️ Alerting, Config & Prometheus (`serve`)

3. Prometheus Metrics Exporter (`serve` mode)