unping 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Funish
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,409 @@
+# UnPing
+
+![npm version](https://img.shields.io/npm/v/unping)
+![npm downloads](https://img.shields.io/npm/dw/unping)
+![npm license](https://img.shields.io/npm/l/unping)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](https://www.contributor-covenant.org/version/2/1/code_of_conduct/)
+
+> Unified network connectivity detection library with multi-driver support
+
+## Features
+
+- 🌐 **Multi-Driver Support**: HTTP, TCP, DNS, and Hybrid drivers for different scenarios
+- 🔄 **Driver Pattern**: Consistent API design across different detection methods
+- 📝 **TypeScript First**: Full type safety with comprehensive ping result types
+- 🚀 **High Performance**: Built on modern networking APIs with minimal dependencies
+- ⚡ **Smart Fallback**: Hybrid driver automatically tries multiple detection methods
+- 🔧 **Flexible Configuration**: Support for batch pings, timeouts, intervals, and custom ports
+- 📊 **Rich Results**: Detailed response data including timing and sequence numbers
+- 🛡️ **Error Resilient**: Graceful handling of network failures and timeouts
+
+## Installation
+
+```bash
+# Install with npm
+$ npm install unping
+
+# Install with yarn
+$ yarn add unping
+
+# Install with pnpm
+$ pnpm add unping
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { createPingManager } from "unping";
+import tcpDriver from "unping/drivers/tcp";
+
+// Create ping manager with TCP driver
+const ping = createPingManager({
+  driver: tcpDriver({ port: 80 }),
+});
+
+// Ping a host
+const results = await ping.ping("google.com");
+console.log(results[0]);
+// { host: "google.com", alive: true, time: 5, sequence: 1 }
+```
+
+### HTTP Driver
+
+Application layer health checks using HTTP HEAD/GET requests.
+
+```typescript
+import httpDriver from "unping/drivers/http";
+
+const http = createPingManager({
+  driver: httpDriver({ method: "HEAD" }),
+});
+
+const results = await http.ping("example.com");
+console.log(`HTTP Status: ${results[0].alive ? "Available" : "Unavailable"}`);
+console.log(`Response Time: ${results[0].time}ms`);
+```
+
+### TCP Driver
+
+Port reachability detection using TCP connections.
+
+```typescript
+import tcpDriver from "unping/drivers/tcp";
+
+// Check default HTTP port
+const tcp80 = createPingManager({
+  driver: tcpDriver({ port: 80 }),
+});
+
+// Check HTTPS port
+const tcp443 = createPingManager({
+  driver: tcpDriver({ port: 443 }),
+});
+
+const results = await tcp80.ping("example.com");
+console.log(`Port 80: ${results[0].alive ? "Open" : "Closed"}`);
+```
+
+### DNS Driver
+
+DNS resolution capability detection.
+
+```typescript
+import dnsDriver from "unping/drivers/dns";
+
+const dns = createPingManager({
+  driver: dnsDriver({
+    type: "A", // Query A records
+    servers: ["8.8.8.8", "1.1.1.1"], // Custom DNS servers
+  }),
+});
+
+const results = await dns.ping("example.com");
+console.log(`DNS Resolution: ${results[0].alive ? "Success" : "Failed"}`);
+```
+
+### Hybrid Driver
+
+Smart detection with automatic fallback between multiple methods.
+
+```typescript
+import hybridDriver from "unping/drivers/hybrid";
+
+const hybrid = createPingManager({
+  driver: hybridDriver({
+    priority: ["tcp", "http", "dns"], // Try TCP first, then HTTP, then DNS
+  }),
+});
+
+// Automatically tries TCP → HTTP → DNS until one succeeds
+const results = await hybrid.ping("example.com");
+console.log(`Detection Method: ${results[0].source || "auto"}`);
+console.log(`Alive: ${results[0].alive}`);
+console.log(`Time: ${results[0].time}ms`);
+```
+
+### Batch Pings
+
+Send multiple pings with intervals for detailed analysis.
+
+```typescript
+const results = await ping.ping("example.com", {
+  count: 5, // Send 5 pings
+  timeout: 3000, // 3 second timeout per ping
+  interval: 500, // Wait 500ms between pings
+});
+
+results.forEach((result) => {
+  console.log(
+    `[${result.sequence}] ${result.host}: ${result.alive ? "✓" : "✗"} ${result.time}ms`,
+  );
+});
+
+// Calculate statistics
+const successRate = results.filter((r) => r.alive).length / results.length;
+const avgTime = results.reduce((sum, r) => sum + r.time, 0) / results.length;
+
+console.log(`Success Rate: ${(successRate * 100).toFixed(1)}%`);
+console.log(`Average Time: ${avgTime.toFixed(0)}ms`);
+```
+
+### Available Drivers
+
+```typescript
+// HTTP driver (application layer)
+import httpDriver from "unping/drivers/http";
+
+// TCP driver (port reachability)
+import tcpDriver from "unping/drivers/tcp";
+
+// DNS driver (DNS resolution)
+import dnsDriver from "unping/drivers/dns";
+
+// Hybrid driver (smart fallback)
+import hybridDriver from "unping/drivers/hybrid";
+```
+
+### Advanced Configuration
+
+#### HTTP Driver Options
+
+```typescript
+import httpDriver from "unping/drivers/http";
+
+const http = createPingManager({
+  driver: httpDriver({
+    method: "GET", // GET or HEAD (default: HEAD)
+    port: 8080, // Custom port
+    https: true, // Force HTTPS
+    path: "/health", // Custom path
+    headers: {
+      // Custom headers
+      "User-Agent": "My-Pinger/1.0",
+    },
+  }),
+});
+```
+
+#### TCP Driver Options
+
+```typescript
+import tcpDriver from "unping/drivers/tcp";
+
+const tcp = createPingManager({
+  driver: tcpDriver({
+    port: 22, // Custom port
+    connectTimeout: 2000, // Connection timeout in ms
+  }),
+});
+```
+
+#### DNS Driver Options
+
+```typescript
+import dnsDriver from "unping/drivers/dns";
+
+const dns = createPingManager({
+  driver: dnsDriver({
+    type: "AAAA", // Query AAAA records (IPv6)
+    servers: ["8.8.8.8"], // Custom DNS servers
+  }),
+});
+```
+
+#### Hybrid Driver Options
+
+```typescript
+import hybridDriver from "unping/drivers/hybrid";
+
+const hybrid = createPingManager({
+  driver: hybridDriver({
+    priority: ["http", "tcp", "dns"], // Custom priority order
+  }),
+});
+```
+
+### Error Handling
+
+```typescript
+try {
+  const results = await ping.ping("example.com", { timeout: 5000 });
+
+  if (results.length > 0) {
+    const result = results[0];
+
+    if (result.alive) {
+      console.log(`Host is reachable: ${result.time}ms`);
+    } else {
+      console.log(`Host is unreachable (timed out)`);
+    }
+  }
+} catch (error) {
+  console.error("Ping failed:", error.message);
+}
+```
+
+## API Reference
+
+### Ping Manager
+
+#### `createPingManager(options)`
+
+Creates a new ping manager instance with the specified driver.
+
+**Parameters:**
+
+- `options.driver` - Ping driver instance (HTTP, TCP, DNS, or Hybrid)
+
+**Returns:** Ping manager instance with `ping()` method
+
+#### Methods
+
+##### `ping(host, options?)`
+
+Ping a host and return results.
+
+**Parameters:**
+
+- `host` (string) - Hostname or IP address to ping
+- `options` (object, optional) - Ping options
+  - `count` (number) - Number of pings to send (default: 1)
+  - `timeout` (number) - Timeout in milliseconds per ping (default: 5000)
+  - `interval` (number) - Wait time in milliseconds between pings (default: 0)
+  - `size` (number) - Packet size in bytes (driver-dependent)
+
+**Returns:** `Promise<PingResult[]>` - Array of ping results
+
+### Ping Result
+
+```typescript
+interface PingResult {
+  host: string; // Target host
+  alive: boolean; // Is reachable
+  time: number; // Response time in milliseconds
+  sequence?: number; // Sequence number for batch pings
+  ttl?: number; // Time to live (when available)
+}
+```
+
+### Driver Options
+
+#### HTTPDriverOptions
+
+```typescript
+interface HTTPDriverOptions {
+  method?: "HEAD" | "GET"; // Request method (default: "HEAD")
+  port?: number; // Custom port (default: 80/443)
+  https?: boolean; // Force HTTPS (default: auto-detect)
+  path?: string; // Request path (default: "/")
+  headers?: Record<string, string>; // Custom headers
+}
+```
+
+#### TCPDriverOptions
+
+```typescript
+interface TCPDriverOptions {
+  port?: number; // Target port (default: 80)
+  connectTimeout?: number; // Connection timeout in ms (default: 5000)
+}
+```
+
+#### DNSDriverOptions
+
+```typescript
+interface DNSDriverOptions {
+  type?: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS"; // Record type (default: "A")
+  servers?: string[]; // DNS servers (default: system DNS)
+}
+```
+
+#### HybridDriverOptions
+
+```typescript
+interface HybridDriverOptions {
+  priority?: Array<"http" | "tcp" | "dns">; // Detection priority (default: ["tcp", "http", "dns"])
+}
+```
+
+## Hybrid Driver Behavior
+
+The Hybrid Driver provides intelligent network connectivity detection by trying multiple methods in order:
+
+1. **TCP (First Priority)**: Fastest method, checks port reachability
+2. **HTTP (Second Priority)**: Confirms application layer availability
+3. **DNS (Last Priority)**: Basic DNS resolution capability as fallback
+
+**Why this order?**
+
+- **TCP First**: Closest to traditional ICMP ping, detects IP layer connectivity quickly (~1-5ms)
+- **HTTP Second**: Validates that the service is actually responding at application level (~100-300ms)
+- **DNS Last**: Only checks if domain can be resolved, doesn't guarantee host reachability (~10-20ms)
+
+**Custom Priority Example:**
+
+```typescript
+// For web service monitoring - prioritize HTTP
+const webMonitor = createPingManager({
+  driver: hybridDriver({ priority: ["http", "tcp", "dns"] }),
+});
+
+// For quick connectivity checks - prioritize TCP
+const quickCheck = createPingManager({
+  driver: hybridDriver({ priority: ["tcp", "dns", "http"] }),
+});
+```
+
+## Use Cases
+
+### Web Service Monitoring
+
+```typescript
+const monitor = createPingManager({
+  driver: httpDriver({ method: "HEAD", path: "/health" }),
+});
+
+setInterval(async () => {
+  const results = await monitor.ping("api.example.com");
+  if (!results[0].alive) {
+    console.error("Service is down!");
+    // Trigger alert
+  }
+}, 60000); // Check every minute
+```
+
+### Port Availability Check
+
+```typescript
+const ports = [22, 80, 443, 8080];
+
+for (const port of ports) {
+  const checker = createPingManager({
+    driver: tcpDriver({ port }),
+  });
+
+  const results = await checker.ping("example.com");
+  console.log(`Port ${port}: ${results[0].alive ? "Open" : "Closed"}`);
+}
+```
+
+### Network Diagnostics
+
+```typescript
+const diagnostic = createPingManager({
+  driver: hybridDriver({ priority: ["tcp", "http", "dns"] }),
+});
+
+const hosts = ["google.com", "github.com", "cloudflare.com"];
+
+for (const host of hosts) {
+  const results = await diagnostic.ping(host);
+  console.log(`${host}: ${results[0].alive ? "✓" : "✗"} ${results[0].time}ms`);
+}
+```
+
+## License
+
+- [MIT](LICENSE) &copy; [Funish](http://www.funish.net/)

package/dist/drivers/dns.cjs

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = dnsDriver;
+exports.pingOnceDNS = pingOnceDNS;
+var _dns = require("dns");
+async function pingOnceDNS(resolver, host, type, timeout, sequence) {
+  const startTime = Date.now();
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("DNS lookup timeout")), timeout);
+    });
+    await Promise.race([resolver.resolve(host, type), timeoutPromise]);
+    return {
+      host,
+      alive: true,
+      time: Date.now() - startTime,
+      sequence
+    };
+  } catch {
+    return {
+      host,
+      alive: false,
+      time: Date.now() - startTime,
+      sequence
+    };
+  }
+}
+function dnsDriver(options = {}) {
+  const {
+    type = "A",
+    servers
+  } = options;
+  const resolver = new _dns.promises.Resolver();
+  if (servers) {
+    resolver.setServers(servers);
+  }
+  const ping = async (host, opts) => {
+    const count = opts?.count || 1;
+    const timeout = opts?.timeout || 5e3;
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      const result = await pingOnceDNS(resolver, host, type, timeout, i + 1);
+      results.push(result);
+      if (i < count - 1 && opts?.interval) {
+        await new Promise(resolve => setTimeout(resolve, opts.interval));
+      }
+    }
+    return results;
+  };
+  return {
+    name: "dns",
+    options,
+    ping
+  };
+}

package/dist/drivers/dns.d.ts

@@ -0,0 +1,10 @@
+import { promises as dnsPromises } from "dns";
+import type { Driver, DriverOptions, PingResult } from "../types";
+export interface DNSDriverOptions extends DriverOptions {
+    /** DNS record type (default: A) */
+    type?: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS";
+    /** DNS servers */
+    servers?: string[];
+}
+export declare function pingOnceDNS(resolver: dnsPromises.Resolver, host: string, type: string, timeout: number, sequence: number): Promise<PingResult>;
+export default function dnsDriver(options?: DNSDriverOptions): Driver;

package/dist/drivers/dns.mjs

@@ -0,0 +1,48 @@
+import { promises as dnsPromises } from "dns";
+export async function pingOnceDNS(resolver, host, type, timeout, sequence) {
+  const startTime = Date.now();
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("DNS lookup timeout")), timeout);
+    });
+    await Promise.race([resolver.resolve(host, type), timeoutPromise]);
+    return {
+      host,
+      alive: true,
+      time: Date.now() - startTime,
+      sequence
+    };
+  } catch {
+    return {
+      host,
+      alive: false,
+      time: Date.now() - startTime,
+      sequence
+    };
+  }
+}
+export default function dnsDriver(options = {}) {
+  const { type = "A", servers } = options;
+  const resolver = new dnsPromises.Resolver();
+  if (servers) {
+    resolver.setServers(servers);
+  }
+  const ping = async (host, opts) => {
+    const count = opts?.count || 1;
+    const timeout = opts?.timeout || 5e3;
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      const result = await pingOnceDNS(resolver, host, type, timeout, i + 1);
+      results.push(result);
+      if (i < count - 1 && opts?.interval) {
+        await new Promise((resolve) => setTimeout(resolve, opts.interval));
+      }
+    }
+    return results;
+  };
+  return {
+    name: "dns",
+    options,
+    ping
+  };
+}

package/dist/drivers/http.cjs

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = httpDriver;
+exports.pingOnceHTTP = pingOnceHTTP;
+var _ofetch = require("ofetch");
+async function pingOnceHTTP(host, protocol, port, path, method, timeout, headers, sequence) {
+  const startTime = Date.now();
+  try {
+    const url = `${protocol}://${host}:${port}${path}`;
+    await (0, _ofetch.ofetch)(url, {
+      method,
+      headers,
+      timeout
+    });
+    return {
+      host,
+      alive: true,
+      time: Date.now() - startTime,
+      sequence
+    };
+  } catch {
+    return {
+      host,
+      alive: false,
+      time: Date.now() - startTime,
+      sequence
+    };
+  }
+}
+function httpDriver(options = {}) {
+  const {
+    method = "HEAD",
+    path = "/",
+    headers = {}
+  } = options;
+  const ping = async (host, opts) => {
+    const count = opts?.count || 1;
+    const timeout = opts?.timeout || 5e3;
+    const results = [];
+    const protocol = options.https ?? options.port === 443 ? "https" : "http";
+    const port = options.port || (protocol === "https" ? 443 : 80);
+    for (let i = 0; i < count; i++) {
+      const result = await pingOnceHTTP(host, protocol, port, path, method, timeout, headers, i + 1);
+      results.push(result);
+      if (i < count - 1 && opts?.interval) {
+        await new Promise(resolve => setTimeout(resolve, opts.interval));
+      }
+    }
+    return results;
+  };
+  return {
+    name: "http",
+    options,
+    ping
+  };
+}

package/dist/drivers/http.d.ts

@@ -0,0 +1,15 @@
+import type { Driver, DriverOptions, PingResult } from "../types";
+export interface HTTPDriverOptions extends DriverOptions {
+    /** Request method (default: HEAD) */
+    method?: "HEAD" | "GET";
+    /** Custom port (default: 80/443) */
+    port?: number;
+    /** Use HTTPS (default: auto detect) */
+    https?: boolean;
+    /** Request path (default: "/") */
+    path?: string;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+export declare function pingOnceHTTP(host: string, protocol: string, port: number, path: string, method: string, timeout: number, headers: Record<string, string>, sequence: number): Promise<PingResult>;
+export default function httpDriver(options?: HTTPDriverOptions): Driver;

package/dist/drivers/http.mjs

@@ -0,0 +1,57 @@
+import { ofetch } from "ofetch";
+export async function pingOnceHTTP(host, protocol, port, path, method, timeout, headers, sequence) {
+  const startTime = Date.now();
+  try {
+    const url = `${protocol}://${host}:${port}${path}`;
+    await ofetch(url, {
+      method,
+      headers,
+      timeout
+    });
+    return {
+      host,
+      alive: true,
+      time: Date.now() - startTime,
+      sequence
+    };
+  } catch {
+    return {
+      host,
+      alive: false,
+      time: Date.now() - startTime,
+      sequence
+    };
+  }
+}
+export default function httpDriver(options = {}) {
+  const { method = "HEAD", path = "/", headers = {} } = options;
+  const ping = async (host, opts) => {
+    const count = opts?.count || 1;
+    const timeout = opts?.timeout || 5e3;
+    const results = [];
+    const protocol = options.https ?? options.port === 443 ? "https" : "http";
+    const port = options.port || (protocol === "https" ? 443 : 80);
+    for (let i = 0; i < count; i++) {
+      const result = await pingOnceHTTP(
+        host,
+        protocol,
+        port,
+        path,
+        method,
+        timeout,
+        headers,
+        i + 1
+      );
+      results.push(result);
+      if (i < count - 1 && opts?.interval) {
+        await new Promise((resolve) => setTimeout(resolve, opts.interval));
+      }
+    }
+    return results;
+  };
+  return {
+    name: "http",
+    options,
+    ping
+  };
+}

package/dist/drivers/hybrid.cjs

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = hybridDriver;
+function hybridDriver(options = {}) {
+  const {
+    priority = ["tcp", "http", "dns"]
+  } = options;
+  const ping = async (host, opts) => {
+    const lastError = new Error("All drivers failed");
+    for (const driverType of priority) {
+      try {
+        let driver;
+        switch (driverType) {
+          case "http":
+            {
+              const {
+                default: httpDriver
+              } = await Promise.resolve().then(() => require("./http.cjs"));
+              driver = httpDriver(options);
+              break;
+            }
+          case "tcp":
+            {
+              const {
+                default: tcpDriver
+              } = await Promise.resolve().then(() => require("./tcp.cjs"));
+              driver = tcpDriver(options);
+              break;
+            }
+          case "dns":
+            {
+              const {
+                default: dnsDriver
+              } = await Promise.resolve().then(() => require("./dns.cjs"));
+              driver = dnsDriver(options);
+              break;
+            }
+          default:
+            continue;
+        }
+        const result = await driver.ping(host, opts);
+        return result;
+      } catch (error) {
+        lastError.cause = error;
+        continue;
+      }
+    }
+    throw lastError;
+  };
+  return {
+    name: "hybrid",
+    options,
+    ping
+  };
+}

package/dist/drivers/hybrid.d.ts

@@ -0,0 +1,6 @@
+import type { Driver, DriverOptions } from "../types";
+export interface HybridDriverOptions extends DriverOptions {
+    /** Priority order of drivers (default: ["tcp", "http", "dns"]) */
+    priority?: Array<"http" | "tcp" | "dns">;
+}
+export default function hybridDriver(options?: HybridDriverOptions): Driver;

package/dist/drivers/hybrid.mjs

@@ -0,0 +1,41 @@
+export default function hybridDriver(options = {}) {
+  const { priority = ["tcp", "http", "dns"] } = options;
+  const ping = async (host, opts) => {
+    const lastError = new Error("All drivers failed");
+    for (const driverType of priority) {
+      try {
+        let driver;
+        switch (driverType) {
+          case "http": {
+            const { default: httpDriver } = await import("./http.mjs");
+            driver = httpDriver(options);
+            break;
+          }
+          case "tcp": {
+            const { default: tcpDriver } = await import("./tcp.mjs");
+            driver = tcpDriver(options);
+            break;
+          }
+          case "dns": {
+            const { default: dnsDriver } = await import("./dns.mjs");
+            driver = dnsDriver(options);
+            break;
+          }
+          default:
+            continue;
+        }
+        const result = await driver.ping(host, opts);
+        return result;
+      } catch (error) {
+        lastError.cause = error;
+        continue;
+      }
+    }
+    throw lastError;
+  };
+  return {
+    name: "hybrid",
+    options,
+    ping
+  };
+}

package/dist/drivers/tcp.cjs

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = tcpDriver;
+exports.pingOnceTCP = pingOnceTCP;
+var _net = require("net");
+async function pingOnceTCP(host, port, timeout, sequence) {
+  return new Promise(resolve => {
+    const socket = new _net.Socket();
+    const startTime = Date.now();
+    let resolved = false;
+    const cleanup = () => {
+      if (resolved) return;
+      resolved = true;
+      socket.destroy();
+    };
+    socket.setTimeout(timeout, () => {
+      cleanup();
+      resolve({
+        host,
+        alive: false,
+        time: timeout,
+        sequence
+      });
+    });
+    socket.on("connect", () => {
+      const time = Date.now() - startTime;
+      cleanup();
+      resolve({
+        host,
+        alive: true,
+        time,
+        sequence
+      });
+    });
+    socket.on("error", () => {
+      cleanup();
+      resolve({
+        host,
+        alive: false,
+        time: Date.now() - startTime,
+        sequence
+      });
+    });
+    socket.connect(port, host);
+  });
+}
+function tcpDriver(options = {}) {
+  const {
+    port = 80,
+    connectTimeout = 5e3
+  } = options;
+  const ping = async (host, opts) => {
+    const count = opts?.count || 1;
+    const timeout = opts?.timeout || connectTimeout;
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      const result = await pingOnceTCP(host, port, timeout, i + 1);
+      results.push(result);
+      if (i < count - 1 && opts?.interval) {
+        await new Promise(resolve => setTimeout(resolve, opts.interval));
+      }
+    }
+    return results;
+  };
+  return {
+    name: "tcp",
+    options,
+    ping
+  };
+}

package/dist/drivers/tcp.d.ts

@@ -0,0 +1,9 @@
+import type { Driver, DriverOptions, PingResult } from "../types";
+export interface TCPDriverOptions extends DriverOptions {
+    /** Target port (default: 80) */
+    port?: number;
+    /** Connection timeout in ms (default: 5000) */
+    connectTimeout?: number;
+}
+export declare function pingOnceTCP(host: string, port: number, timeout: number, sequence: number): Promise<PingResult>;
+export default function tcpDriver(options?: TCPDriverOptions): Driver;

package/dist/drivers/tcp.mjs

@@ -0,0 +1,63 @@
+import { Socket } from "net";
+export async function pingOnceTCP(host, port, timeout, sequence) {
+  return new Promise((resolve) => {
+    const socket = new Socket();
+    const startTime = Date.now();
+    let resolved = false;
+    const cleanup = () => {
+      if (resolved) return;
+      resolved = true;
+      socket.destroy();
+    };
+    socket.setTimeout(timeout, () => {
+      cleanup();
+      resolve({
+        host,
+        alive: false,
+        time: timeout,
+        sequence
+      });
+    });
+    socket.on("connect", () => {
+      const time = Date.now() - startTime;
+      cleanup();
+      resolve({
+        host,
+        alive: true,
+        time,
+        sequence
+      });
+    });
+    socket.on("error", () => {
+      cleanup();
+      resolve({
+        host,
+        alive: false,
+        time: Date.now() - startTime,
+        sequence
+      });
+    });
+    socket.connect(port, host);
+  });
+}
+export default function tcpDriver(options = {}) {
+  const { port = 80, connectTimeout = 5e3 } = options;
+  const ping = async (host, opts) => {
+    const count = opts?.count || 1;
+    const timeout = opts?.timeout || connectTimeout;
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      const result = await pingOnceTCP(host, port, timeout, i + 1);
+      results.push(result);
+      if (i < count - 1 && opts?.interval) {
+        await new Promise((resolve) => setTimeout(resolve, opts.interval));
+      }
+    }
+    return results;
+  };
+  return {
+    name: "tcp",
+    options,
+    ping
+  };
+}

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";function createPingManager(r){const{driver:n}=r;return{ping:async(e,t)=>{if(!n.ping)throw new Error("Driver does not implement ping method");return await n.ping(e,t)}}}exports.createPingManager=createPingManager;

package/dist/index.d.cts

@@ -0,0 +1,53 @@
+/**
+ * UnPing Types
+ * Unified network ping library with multi-driver support
+ */
+interface PingResult {
+    /** Target host */
+    host: string;
+    /** Is alive */
+    alive: boolean;
+    /** Response time (ms) */
+    time: number;
+    /** Sequence number */
+    sequence?: number;
+    /** TTL */
+    ttl?: number;
+}
+interface DriverOptions {
+    [key: string]: any;
+}
+interface PingOptions {
+    /** Ping count (default: 1) */
+    count?: number;
+    /** Timeout in ms (default: 5000) */
+    timeout?: number;
+    /** Packet size in bytes */
+    size?: number;
+    /** Interval between pings in ms */
+    interval?: number;
+}
+type MaybePromise<T> = T | Promise<T>;
+interface Driver<OptionsT = DriverOptions> {
+    name?: string;
+    options?: OptionsT;
+    ping?: (host: string, options?: PingOptions) => MaybePromise<PingResult[]>;
+}
+interface PingManagerOptions {
+    driver: Driver;
+}
+
+/**
+ * UnPing - Unified network ping library
+ * A comprehensive ping library with multi-driver support
+ */
+
+declare function createPingManager(options: PingManagerOptions): {
+    /**
+     * Ping a host - always returns array
+     */
+    ping: (host: string, opts?: PingOptions) => Promise<PingResult[]>;
+};
+
+export { createPingManager };
+export type { Driver, DriverOptions, MaybePromise, PingManagerOptions, PingOptions, PingResult };

package/dist/index.d.mts

@@ -0,0 +1,53 @@
+/**
+ * UnPing Types
+ * Unified network ping library with multi-driver support
+ */
+interface PingResult {
+    /** Target host */
+    host: string;
+    /** Is alive */
+    alive: boolean;
+    /** Response time (ms) */
+    time: number;
+    /** Sequence number */
+    sequence?: number;
+    /** TTL */
+    ttl?: number;
+}
+interface DriverOptions {
+    [key: string]: any;
+}
+interface PingOptions {
+    /** Ping count (default: 1) */
+    count?: number;
+    /** Timeout in ms (default: 5000) */
+    timeout?: number;
+    /** Packet size in bytes */
+    size?: number;
+    /** Interval between pings in ms */
+    interval?: number;
+}
+type MaybePromise<T> = T | Promise<T>;
+interface Driver<OptionsT = DriverOptions> {
+    name?: string;
+    options?: OptionsT;
+    ping?: (host: string, options?: PingOptions) => MaybePromise<PingResult[]>;
+}
+interface PingManagerOptions {
+    driver: Driver;
+}
+
+/**
+ * UnPing - Unified network ping library
+ * A comprehensive ping library with multi-driver support
+ */
+
+declare function createPingManager(options: PingManagerOptions): {
+    /**
+     * Ping a host - always returns array
+     */
+    ping: (host: string, opts?: PingOptions) => Promise<PingResult[]>;
+};
+
+export { createPingManager };
+export type { Driver, DriverOptions, MaybePromise, PingManagerOptions, PingOptions, PingResult };

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * UnPing Types
+ * Unified network ping library with multi-driver support
+ */
+interface PingResult {
+    /** Target host */
+    host: string;
+    /** Is alive */
+    alive: boolean;
+    /** Response time (ms) */
+    time: number;
+    /** Sequence number */
+    sequence?: number;
+    /** TTL */
+    ttl?: number;
+}
+interface DriverOptions {
+    [key: string]: any;
+}
+interface PingOptions {
+    /** Ping count (default: 1) */
+    count?: number;
+    /** Timeout in ms (default: 5000) */
+    timeout?: number;
+    /** Packet size in bytes */
+    size?: number;
+    /** Interval between pings in ms */
+    interval?: number;
+}
+type MaybePromise<T> = T | Promise<T>;
+interface Driver<OptionsT = DriverOptions> {
+    name?: string;
+    options?: OptionsT;
+    ping?: (host: string, options?: PingOptions) => MaybePromise<PingResult[]>;
+}
+interface PingManagerOptions {
+    driver: Driver;
+}
+
+/**
+ * UnPing - Unified network ping library
+ * A comprehensive ping library with multi-driver support
+ */
+
+declare function createPingManager(options: PingManagerOptions): {
+    /**
+     * Ping a host - always returns array
+     */
+    ping: (host: string, opts?: PingOptions) => Promise<PingResult[]>;
+};
+
+export { createPingManager };
+export type { Driver, DriverOptions, MaybePromise, PingManagerOptions, PingOptions, PingResult };

package/dist/index.mjs

@@ -0,0 +1 @@
+function t(r){const{driver:n}=r;return{ping:async(e,i)=>{if(!n.ping)throw new Error("Driver does not implement ping method");return await n.ping(e,i)}}}export{t as createPingManager};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "unping",
+  "version": "0.0.0",
+  "description": "Unified network ping library with multi-driver support",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./drivers/*": {
+      "import": "./dist/drivers/*.mjs",
+      "require": "./dist/drivers/*.cjs",
+      "types": "./dist/drivers/*.d.ts"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/funish/axis.git"
+  },
+  "keywords": [
+    "ping",
+    "network",
+    "tcp",
+    "http",
+    "dns",
+    "latency",
+    "monitoring",
+    "connectivity",
+    "typescript"
+  ],
+  "author": {
+    "name": "Funish",
+    "email": "contact@funish.net",
+    "url": "http://www.funish.net/"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/funish/axis/issues"
+  },
+  "homepage": "https://github.com/funish/axis#readme",
+  "dependencies": {
+    "ofetch": "1.4.1"
+  },
+  "scripts": {
+    "dev": "unbuild --stub",
+    "build": "unbuild"
+  }
+}