isitup-cli 0.1.0__py3-none-any.whl

isitup/output.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import json
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+
+from .checks import CheckResult, Status, ping_status_for, probe_target, run_pings
+from .config import Target, TargetKind
+from .history import HistoryStore
+from .render import fmt_ms, overall_status, service_label
+
+FIELD_WIDTHS = {"status": 8, "target": 30, "ping": 7, "service": 12}
+
+
+def run_checks(
+    targets: list[Target], ping_enabled: bool, ping_timeout: float, http_timeout: float
+) -> list[CheckResult]:
+    """Run checks for all targets — without any progress UI, used for
+    --plain/--json output where nothing should be printed except results.
+
+    Ping each unique host once (targets sharing a host share a ping), then
+    run each target's own HTTP/TCP probe concurrently.
+    """
+    ping_results = run_pings(targets, ping_enabled, ping_timeout)
+
+    with ThreadPoolExecutor(max_workers=min(len(targets), 16) or 1) as pool:
+        futures = {}
+        for target in targets:
+            ping_status, ping_latency_ms = ping_status_for(target, ping_enabled, ping_results)
+            futures[pool.submit(probe_target, target, ping_status, ping_latency_ms, http_timeout)] = target
+        results = [future.result() for future in futures]
+
+    order = {target.raw: i for i, target in enumerate(targets)}
+    results.sort(key=lambda r: order[r.target.raw])
+    return results
+
+
+def compute_exit_code(results: list[CheckResult]) -> int:
+    return 1 if any(overall_status(r)[0] == Status.DOWN for r in results) else 0
+
+
+def _iso(value: float | None) -> str | None:
+    return datetime.fromtimestamp(value).isoformat() if value is not None else None
+
+
+def result_to_dict(result: CheckResult, history: HistoryStore) -> dict:
+    _, status_label = overall_status(result)
+    target_history = history.get(result.target.raw)
+    return {
+        "target": result.target.display_name,
+        "url": result.target.url,
+        "hostname": result.target.hostname,
+        "status": status_label,
+        "ping": {
+            "status": result.ping_status.value,
+            "latency_ms": result.ping_latency_ms,
+        },
+        "http": (
+            {
+                "status": result.http_status.value if result.http_status else None,
+                "code": result.http_code,
+                "latency_ms": result.http_latency_ms,
+                "error_kind": result.error_kind,
+            }
+            if result.target.kind == TargetKind.HTTP
+            else None
+        ),
+        "tcp": (
+            {
+                "status": result.tcp_status.value if result.tcp_status else None,
+                "port": result.target.port,
+                "latency_ms": result.tcp_latency_ms,
+                "error_kind": result.error_kind,
+            }
+            if result.target.kind == TargetKind.TCP_PORT
+            else None
+        ),
+        "min_latency_ms": target_history.min_latency,
+        "max_latency_ms": target_history.max_latency,
+        "last_online": _iso(target_history.last_online),
+        "last_offline": _iso(target_history.last_offline),
+        "detail": result.detail,
+        "checked_at": _iso(result.checked_at),
+    }
+
+
+def format_json_line(result: CheckResult, history: HistoryStore) -> str:
+    return json.dumps(result_to_dict(result, history))
+
+
+def format_plain_line(result: CheckResult, history: HistoryStore) -> str:
+    _, status_label = overall_status(result)
+    target_history = history.get(result.target.raw)
+    checked = datetime.fromtimestamp(result.checked_at).strftime("%Y-%m-%d %H:%M:%S")
+
+    service_field = ""
+    if result.target.kind == TargetKind.HTTP:
+        service_field = f"http={service_label(result):<{FIELD_WIDTHS['service']}} "
+    elif result.target.kind == TargetKind.TCP_PORT:
+        service_field = f"tcp={service_label(result):<{FIELD_WIDTHS['service']}} "
+
+    return (
+        f"{checked} "
+        f"{status_label:<{FIELD_WIDTHS['status']}} "
+        f"{result.target.display_name:<{FIELD_WIDTHS['target']}} "
+        f"ping={result.ping_status.value:<{FIELD_WIDTHS['ping']}} "
+        f"{service_field}"
+        f"latency={fmt_ms(result.latency_ms):>8} "
+        f"min={fmt_ms(target_history.min_latency):>8} "
+        f"max={fmt_ms(target_history.max_latency):>8} "
+        f'detail="{result.detail}"'
+    )

isitup/render.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+
+import time
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from textwrap import dedent
+
+from rich.align import Align
+from rich.console import Console, Group, RenderableType
+from rich.live import Live
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskID, TextColumn
+from rich.table import Table
+from rich.text import Text
+
+from .checks import CheckResult, Status, ping_status_for, probe_target, run_pings
+from .config import Target, TargetKind
+from .history import HistoryStore
+
+WORDMARK_MARKUP = (
+    "[#DBDBDA]   ██           ██    ██   [/] [#00E359]                 [/]\n"
+    "[#DBDBDA]                      ██   [/] [#00E359]                 [/]\n"
+    "[#DBDBDA]  ▀██   ▄█▀▀   ▀██  ▀▀██▀▀ [/] [#00E359]██ ██  ██▀█▄    [/]\n"
+    "[#DBDBDA]   ██   ▀█▄▄    ██    ██   [/] [#00E359]██ ██  ██ ██    [/]\n"
+    "[#DBDBDA]   ██      ██   ██    ██▄  [/] [#00E359]██ ██  ██▀▀     [/]\n"
+    "[#DBDBDA]  ▀▀▀▀  ▀▀▀▀   ▀▀▀▀    ▀▀  [/] [#00E359] ▀▀▀▀  ██       [/]\n"
+    "[#00E359] ⬤───────────────────────╱╲╱────────────⬤       [/]\n"
+)
+WORDMARK = Text.from_markup(WORDMARK_MARKUP)
+WORDMARK.no_wrap = True
+
+MASCOT_MARKUP = dedent(r"""
+                  [#A8AAA8]╭────╮[/]
+              [#A8AAA8]╭───╯    ╰──╮[/]
+             [#A8AAA8]╭╯[/]    [#00E359]↑[/] [#FF4D3D]↓[/]    [#A8AAA8]╰╮[/]
+             [#A8AAA8]╰─────┬────────╯[/]
+                   [#00E359]│[/]
+  [#A8AAA8]╭─┬─╮       ╭────┴──────────╮         ╭───────╮[/]
+[#A8AAA8]╭─┼─┼─┼─╮─────│[/]               [#A8AAA8]│[/][#00E359]───╱╲╱───[/][#A8AAA8]┤[/] [#00E359]●[/]   [#FFD43B]●[/] [#A8AAA8]│[/]
+[#A8AAA8]├─┼─┼─┼─┤     │[/]    [#00E359]⌃     ⌃[/]    [#A8AAA8]│         ├───────┤[/]
+[#A8AAA8]╰─┼─┼─┼─╯     │[/]     [#00E359]• • •[/]     [#A8AAA8]│         │[/] [#00E359]●[/]   [#FFD43B]●[/] [#A8AAA8]│[/]
+  [#A8AAA8]╰─┴─╯       ╰───────────────╯         ├───────┤[/]
+                  [#A8AAA8]╱       ╲             │[/] [#FFD43B]●[/]   [#FF4D3D]●[/] [#A8AAA8]│[/]
+               [#A8AAA8]╭─╯         ╰─╮          ╰───────╯[/]
+               [#A8AAA8]╰────┐   ┌────╯[/]
+                    [#A8AAA8]╰───╯[/]
+""").strip("\n")
+MASCOT = Text.from_markup(MASCOT_MARKUP)
+MASCOT.no_wrap = True
+
+
+def _header(show_mascot: bool) -> RenderableType:
+    """Mascot on the left, wordmark vertically centered against it, the
+    pair centered as one lockup in the available width. Once real results
+    have rendered once, drop the mascot and keep just the wordmark."""
+    if not show_mascot:
+        return Align.center(WORDMARK)
+    grid = Table.grid(padding=(0, 2, 0, 0))
+    grid.add_column()
+    grid.add_column(vertical="middle")
+    grid.add_row(MASCOT, WORDMARK)
+    return Align.center(grid)
+
+
+def framed(base: RenderableType, *rest: RenderableType) -> Group:
+    """Prefix `base` (plus any extra renderables, e.g. a progress bar) with
+    a blank line, the header, and another blank line. `base` is also what's
+    being framed, so it doubles as the signal for whether a results table
+    has ever been shown yet: while it's still the waiting placeholder, the
+    header includes the mascot; once it's an actual results table, later
+    calls (even mid-round, with a stale table as `base`) show wordmark only.
+    """
+    show_mascot = not isinstance(base, Table)
+    return Group("", _header(show_mascot), "", base, *rest)
+
+
+STATUS_STYLE = {
+    Status.OK: "bold green",
+    Status.WARN: "bold yellow",
+    Status.DOWN: "bold red",
+    Status.UNKNOWN: "dim",
+}
+
+STATUS_LABEL = {
+    Status.OK: "UP",
+    Status.WARN: "WARN",
+    Status.DOWN: "DOWN",
+    Status.UNKNOWN: "-",
+}
+
+ERROR_KIND_LABEL = {
+    "dns": "DNS",
+    "tls": "TLS",
+    "redirect": "REDIRECT",
+    "timeout": "TIMEOUT",
+    "connection": "CONN",
+    "request_error": "ERROR",
+}
+
+PHASE_LABEL = {
+    "queued": "queued",
+    "ping": "pinging…",
+    "http": "http check…",
+    "tcp": "checking port…",
+    "done": "done",
+}
+
+
+def overall_status(result: CheckResult) -> tuple[Status, str]:
+    """A host that blocks ICMP but serves its actual service fine is still
+    up — the probe (HTTP/TCP) takes priority over ping, which is just extra
+    diagnostic info. Ping-only targets have no probe, so ping *is* the signal."""
+    target = result.target
+
+    if target.kind == TargetKind.PING_ONLY:
+        if result.ping_status == Status.OK:
+            return Status.OK, "UP"
+        if result.ping_status == Status.DOWN:
+            return Status.DOWN, "OFFLINE"
+        return Status.UNKNOWN, "NO CHECK"
+
+    if target.kind == TargetKind.TCP_PORT:
+        if result.tcp_status == Status.OK:
+            return Status.OK, "UP"
+        if result.ping_status == Status.DOWN:
+            return Status.DOWN, "OFFLINE"
+        return Status.DOWN, "PORT DOWN"
+
+    if result.http_status == Status.OK:
+        return Status.OK, "UP"
+    if result.http_status == Status.WARN:
+        return Status.WARN, "WARN"
+    if result.ping_status == Status.DOWN:
+        return Status.DOWN, "OFFLINE"
+    return Status.DOWN, "HTTP DOWN"
+
+
+def is_online(result: CheckResult) -> bool:
+    return overall_status(result)[0] != Status.DOWN
+
+
+def fmt_ms(value: float | None) -> str:
+    return f"{value:.0f} ms" if value is not None else "-"
+
+
+def fmt_time(value: float | None) -> str:
+    return datetime.fromtimestamp(value).strftime("%H:%M:%S") if value is not None else "never"
+
+
+def _error_label(error_kind: str) -> str:
+    return ERROR_KIND_LABEL.get(error_kind, error_kind.upper())
+
+
+def service_label(result: CheckResult) -> str:
+    """Label for whichever probe applies to this target (HTTP or TCP) — the
+    interactive UI shows both in the same column since a target only ever
+    has one or the other."""
+    target = result.target
+
+    if target.kind == TargetKind.HTTP:
+        label = STATUS_LABEL[result.http_status] if result.http_status else STATUS_LABEL[Status.UNKNOWN]
+        if result.http_code is not None:
+            return f"{label} ({result.http_code})"
+        if result.error_kind:
+            return f"{label} ({_error_label(result.error_kind)})"
+        return label
+
+    if target.kind == TargetKind.TCP_PORT:
+        label = STATUS_LABEL[result.tcp_status] if result.tcp_status else STATUS_LABEL[Status.UNKNOWN]
+        if result.tcp_status == Status.DOWN and result.error_kind:
+            return f"{label} ({_error_label(result.error_kind)})"
+        return f"{label} ({target.port})"
+
+    return "-"
+
+
+def service_style(result: CheckResult) -> str:
+    target = result.target
+    if target.kind == TargetKind.HTTP:
+        return STATUS_STYLE[result.http_status or Status.UNKNOWN]
+    if target.kind == TargetKind.TCP_PORT:
+        return STATUS_STYLE[result.tcp_status or Status.UNKNOWN]
+    return STATUS_STYLE[Status.UNKNOWN]
+
+
+def build_table(results: list[CheckResult], history: HistoryStore) -> Table:
+    table = Table(expand=True)
+    table.add_column("Target")
+    table.add_column("Status", justify="center")
+    table.add_column("Ping", justify="center")
+    table.add_column("Service", justify="center")
+    table.add_column("Latency", justify="right")
+    table.add_column("Min", justify="right")
+    table.add_column("Max", justify="right")
+    table.add_column("Trend", justify="left")
+    table.add_column("Last Online", justify="right")
+    table.add_column("Last Offline", justify="right")
+    table.add_column("Detail")
+    table.add_column("Checked", justify="right")
+
+    for result in results:
+        status, status_label = overall_status(result)
+        status_style = STATUS_STYLE[status]
+
+        ping_label = STATUS_LABEL[result.ping_status]
+        if result.ping_status == Status.OK and result.ping_latency_ms is not None:
+            ping_label += f" {result.ping_latency_ms:.0f}ms"
+        ping_style = STATUS_STYLE[result.ping_status]
+
+        target_history = history.get(result.target.raw)
+
+        table.add_row(
+            result.target.display_name,
+            f"[{status_style}]{status_label}[/{status_style}]",
+            f"[{ping_style}]{ping_label}[/{ping_style}]",
+            f"[{service_style(result)}]{service_label(result)}[/{service_style(result)}]",
+            fmt_ms(result.latency_ms),
+            fmt_ms(target_history.min_latency),
+            fmt_ms(target_history.max_latency),
+            target_history.sparkline or "-",
+            fmt_time(target_history.last_online),
+            fmt_time(target_history.last_offline),
+            result.detail,
+            fmt_time(result.checked_at),
+        )
+
+    return table
+
+
+def waiting_placeholder() -> Text:
+    return Text("waiting for first check…", style="dim")
+
+
+def _probe_phase(target: Target) -> str:
+    if target.kind == TargetKind.HTTP:
+        return "http"
+    if target.kind == TargetKind.TCP_PORT:
+        return "tcp"
+    return "done"
+
+
+def run_round(
+    console: Console,
+    targets: list[Target],
+    ping_enabled: bool,
+    ping_timeout: float,
+    http_timeout: float,
+    live: Live,
+    base: RenderableType,
+) -> list[CheckResult]:
+    """Run checks for all targets in two phases: first ping every unique
+    host once (targets pointing at the same host share a ping), then run
+    each target's own follow-up probe (HTTP/TCP) concurrently. A live
+    spinner and progress bar per target track both phases, rendered above
+    whatever `base` (the previous results table) currently is."""
+    progress = Progress(
+        SpinnerColumn(finished_text="[bold green]✓[/bold green]"),
+        TextColumn("[bold]{task.fields[name]}[/bold]", justify="left"),
+        BarColumn(bar_width=24),
+        TextColumn("{task.fields[phase]}"),
+        console=console,
+    )
+
+    task_ids: dict[str, TaskID] = {
+        target.raw: progress.add_task("", total=100, name=target.display_name, phase=PHASE_LABEL["queued"])
+        for target in targets
+    }
+
+    def wants_ping(target: Target) -> bool:
+        return target.ping and ping_enabled
+
+    # Phase 1: ping each unique host once.
+    pinging = [t for t in targets if wants_ping(t)]
+    for target in pinging:
+        progress.update(task_ids[target.raw], phase=PHASE_LABEL["ping"])
+
+    ping_results: dict[str, tuple[Status, float | None]] = {}
+    if pinging:
+        # run_pings already dedups by host and pings concurrently internally;
+        # wrap it in one future purely so we can poll for progress animation.
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(run_pings, pinging, True, ping_timeout)
+            start = time.monotonic()
+            while not future.done():
+                pct = min((time.monotonic() - start) / ping_timeout, 1.0) * 100 if ping_timeout else 100
+                for target in pinging:
+                    progress.update(task_ids[target.raw], completed=pct)
+                live.update(framed(base, progress))
+                time.sleep(0.05)
+            ping_results = future.result()
+
+    for target in pinging:
+        progress.update(task_ids[target.raw], completed=100)
+
+    # Phase 2: each target's own HTTP/TCP probe (or nothing, for ping-only).
+    for target in targets:
+        progress.update(task_ids[target.raw], completed=0, phase=PHASE_LABEL[_probe_phase(target)])
+    live.update(framed(base, progress))
+
+    results: list[CheckResult] = []
+    with ThreadPoolExecutor(max_workers=min(len(targets), 16) or 1) as pool:
+        futures = {}
+        for target in targets:
+            ping_status, ping_latency_ms = ping_status_for(target, ping_enabled, ping_results)
+            futures[pool.submit(probe_target, target, ping_status, ping_latency_ms, http_timeout)] = target
+
+        start = time.monotonic()
+        probing = [t for t in targets if t.kind != TargetKind.PING_ONLY]
+        while not all(f.done() for f in futures):
+            pct = min((time.monotonic() - start) / http_timeout, 1.0) * 100 if http_timeout else 100
+            for target in probing:
+                progress.update(task_ids[target.raw], completed=pct)
+            live.update(framed(base, progress))
+            time.sleep(0.05)
+
+        for task_id in task_ids.values():
+            progress.update(task_id, completed=100, phase=PHASE_LABEL["done"])
+        live.update(framed(base, progress))
+
+        for probe_future in futures:
+            results.append(probe_future.result())
+
+    order = {target.raw: i for i, target in enumerate(targets)}
+    results.sort(key=lambda r: order[r.target.raw])
+    return results
+
+
+def countdown(console: Console, live: Live, table: RenderableType, seconds: float) -> None:
+    progress = Progress(
+        TextColumn("[dim]next check in[/dim]"),
+        BarColumn(bar_width=24),
+        TextColumn("{task.fields[remaining]}"),
+        console=console,
+    )
+    task_id = progress.add_task("", total=seconds, remaining=f"{seconds:.0f}s")
+    start = time.monotonic()
+    while True:
+        elapsed = time.monotonic() - start
+        if elapsed >= seconds:
+            break
+        progress.update(task_id, completed=elapsed, remaining=f"{seconds - elapsed:.0f}s")
+        live.update(framed(table, progress))
+        time.sleep(0.2)

isitup_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: isitup-cli
+Version: 0.1.0
+Summary: A small CLI that periodically checks whether servers respond to ping, HTTP, and TCP ports
+Author: stefan.insam
+Author-email: stefan.insam <stefan.insam@netgo.de>
+License-Expression: GPL-3.0-only
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: System :: Networking :: Monitoring
+Classifier: Topic :: Utilities
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: requests>=2.34.2
+Requires-Dist: rich>=15.0.0
+Requires-Python: >=3.14
+Project-URL: Repository, https://github.com/ramsesoriginal/isitup
+Project-URL: Issues, https://github.com/ramsesoriginal/isitup/issues
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="logo/main_hero.svg" alt="isitup" width="720">
+
+  <p><strong>Is it up? Ping, HTTP, and TCP checks in one small, fast CLI.</strong></p>
+
+  [![PyPI](https://img.shields.io/pypi/v/isitup-cli?color=blue)](https://pypi.org/project/isitup-cli/)
+  [![CI](https://github.com/ramsesoriginal/isitup/actions/workflows/ci.yml/badge.svg)](https://github.com/ramsesoriginal/isitup/actions/workflows/ci.yml)
+  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](LICENSE)
+  [![Python 3.14+](https://img.shields.io/badge/python-3.14%2B-3776AB?logo=python&logoColor=white)](pyproject.toml)
+  [![uv](https://img.shields.io/badge/uv-managed-DE5FE9?logo=uv&logoColor=white)](https://github.com/astral-sh/uv)
+  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+  [![GitHub stars](https://img.shields.io/github/stars/ramsesoriginal/isitup?style=social)](https://github.com/ramsesoriginal/isitup)
+</div>
+
+---
+
+**isitup** is a small CLI that periodically checks whether servers respond to ping and,
+depending on how the target is written, HTTP or a TCP port:
+
+| Target | Checks |
+| --- | --- |
+| `example.com` | ping only |
+| `example.com:1337` | ping + TCP connect to port 1337 |
+| `http://example.com` / `https://example.com` | ping + HTTP (catching a 500, a DNS failure, an expired TLS certificate, a redirect loop, etc.) |
+| `https://example.com:1337` | ping + HTTP, against that port |
+
+Ping is checked independently from the HTTP/TCP probe: many hosts (behind
+load balancers, CDNs, or firewalls) drop ICMP but serve their actual service
+just fine, so a blocked ping alone doesn't mark a target down: the "Status"
+column is based on the probe (HTTP or TCP), with ping shown alongside as
+extra diagnostic info. A target only shows as `OFFLINE` when both ping and
+the probe fail; a ping-only target's status is based on ping alone, since
+there's nothing else to check.
+
+If the same host appears more than once (e.g. `example.com` and
+`https://example.com/health`), it's only pinged once per round. The ping
+result is shared across all targets pointing at that host.
+
+While checks are running you get a live spinner and a progress bar per
+target counting down its timeout; results are then shown in a table that
+updates in place (via [`rich`](https://github.com/Textualize/rich)) rather
+than reprinting on every round.
+
+Each target also keeps a rolling window of its last 20 response times for
+the session (HTTP response time or TCP connect time, whichever applies),
+shown as Min/Max latency columns and a tiny sparkline ("Trend"), along with
+the last time it was seen online and the last time it was seen offline.
+This history is in-memory only and resets each time you start the tool.
+
+## Installation
+
+The package is published on PyPI as `isitup-cli`, but it installs a plain
+`isitup` command:
+
+```bash
+uv tool install isitup-cli
+# or: pipx install isitup-cli
+# or: pip install isitup-cli
+```
+
+To try unreleased changes straight from `main` instead (no PyPI release
+needed):
+
+```bash
+uv tool install git+https://github.com/ramsesoriginal/isitup
+```
+
+Either way, remove it later with `uv tool uninstall isitup`.
+
+## Usage
+
+```bash
+isitup --url example.com --url https://example.org --url db.internal:5432
+```
+
+Or with a config file:
+
+```bash
+cp config.example.yaml config.yaml
+# edit config.yaml
+isitup --config config.yaml
+```
+
+Config files and `--url` flags can be combined; the tool watches the union of
+both. The config file is watched for changes and reloaded automatically:
+add, remove, or edit targets without restarting the tool (`--url` targets
+can't change at runtime, only what's in the file).
+
+### Options
+
+| Flag | Description |
+| --- | --- |
+| `-c`, `--config PATH` | YAML file listing targets; reloaded automatically on change |
+| `-u`, `--url TARGET` | a target to monitor (repeatable): hostname, `hostname:port`, or a URL |
+| `-i`, `--interval SECONDS` | seconds between check rounds (default: 30) |
+| `--ping-timeout SECONDS` | ping reply timeout (default: 2) |
+| `--http-timeout SECONDS` | timeout for the HTTP request or TCP connect (default: 5) |
+| `--no-ping` | skip ICMP entirely, HTTP/TCP-only checks |
+| `--once` | run a single round and exit; exit code is `1` if any target is down, `0` otherwise. Useful as a cron/CI health gate |
+| `--plain` | print one plain-text line per target per round instead of the live UI (for logging/piping) |
+| `--json` | print one JSON object per target per round instead of the live UI (for machine consumption) |
+
+`--plain` and `--json` are mutually exclusive with each other, and both skip
+the interactive spinner/progress UI entirely.
+
+### Note on ping
+
+Some servers/networks (common on cloud providers, behind load balancers or
+CDNs) block ICMP echo requests entirely even though the service itself is
+perfectly reachable. The "Status" column already accounts for this and
+won't flag such a target as down (unless it's ping-only, in which case ping
+*is* the only signal there is). If you'd rather not run ping checks against
+a target at all (e.g. to skip the ~2s ping timeout), either set `ping: false`
+for it in the config file, or pass `--no-ping` to disable ICMP checks
+globally. Note that a ping-only target (bare hostname, no port) can't have
+`ping: false`, there would be nothing left to check.
+
+### Failure classification
+
+When the HTTP or TCP probe fails, the specific reason is captured as
+`error_kind` (visible in `--json` output, and shown as a short tag like
+`DOWN (DNS)` in the Service column otherwise):
+
+| `error_kind` | Meaning |
+| --- | --- |
+| `dns` | the hostname failed to resolve |
+| `tls` | a TLS/certificate error (HTTP only, e.g. expired or self-signed cert) |
+| `redirect` | too many redirects (HTTP only, possible redirect loop) |
+| `timeout` | didn't complete within `--http-timeout` |
+| `connection` | connection refused or otherwise unreachable |
+| `client_error` / `server_error` | got a 4xx / 5xx HTTP response |
+| `request_error` | anything else `requests` raised |
+
+## Development
+
+```bash
+uv sync
+uv run isitup --once --url https://example.com
+
+uv run pytest       # tests
+uv run ruff check .    # lint
+uv run ruff format .   # format
+uv run mypy src tests  # type check
+```
+
+Every push and pull request runs this same lint/type-check/test suite via
+[GitHub Actions](.github/workflows/ci.yml), across Linux and Windows.
+
+### Releasing
+
+Pushing a tag matching `vX.Y.Z` builds the package and publishes it to PyPI
+via [Trusted Publishing](https://docs.pypi.org/trusted-publishers/) (see
+[`.github/workflows/publish.yml`](.github/workflows/publish.yml)), no API
+token stored anywhere:
+
+```bash
+# bump `version` in pyproject.toml first (skip this for the very first
+# release: it's already at 0.1.0), then:
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+## License
+
+[GPL-3.0](LICENSE): see [LICENSE](LICENSE) for the full text.

isitup_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+isitup/__init__.py,sha256=oKsCpoiQSSXx57DGs2VfYzeO1ukJQxdGnV-2hC3BI0M,42
+isitup/checks.py,sha256=SDkPinxtx0tYXofZ_CcFxFXBuHJnXbTpMH1nVS8-ny8,7348
+isitup/cli.py,sha256=NCzqug5G8CtQKxFBBLK6WQEbCUaOeyBl9BY4glXfe1c,6248
+isitup/config.py,sha256=WO14EjLVo5huKOPGdw9enjcCHvQUhPLdOz3b3oBDIQc,4941
+isitup/history.py,sha256=BT-j6pK1AUYbMIz2xrTNCz5dzs9KMsMSFgjTPKXccfE,1912
+isitup/output.py,sha256=UhhwKYXDI3Z0J-djBDC9V0ZWEbTFlsbLrqp4M5YCKto,4327
+isitup/render.py,sha256=dM4FxJrYeNanfR-NNNSbgyA127ujVLrIFZlwMNIwNpI,13734
+isitup_cli-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+isitup_cli-0.1.0.dist-info/WHEEL,sha256=y6e-a5KI2W-qDAJKfh9Xr81bin8NgUdfWgz3VSXXpe4,80
+isitup_cli-0.1.0.dist-info/entry_points.txt,sha256=qtY-K4y-86S5h3ABNK9FAH9ABDZflPqoTS1VE9F98y8,40
+isitup_cli-0.1.0.dist-info/METADATA,sha256=0WWmEqMQFfpWWlz33vdjJEkrktv7JRRLr-cjBjiPI3I,7800
+isitup_cli-0.1.0.dist-info/RECORD,,

isitup_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.9
+Root-Is-Purelib: true
+Tag: py3-none-any

isitup_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+isitup = isitup:main
+