2.1.2

.gitea/workflows/default_nottags.yaml

@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

.gitignore

@@ -3,7 +3,6 @@
 # artifacts
 coverage/
 public/
-pages/
 
 # installs
 node_modules/
@@ -17,4 +16,4 @@ node_modules/
 dist/
 dist_*/
 
-# custom
+#------# custom

.gitlab-ci.yml

@@ -1,128 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-before_script:
-  - npm install -g @shipzone/npmci
-
-# ====================
-# security stage
-# ====================
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --production --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=prod --production
-  tags:
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=dev
-  tags:
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  only:
-    - tags
-  script:
-    - npmci command npm install -g typescript
-    - npmci npm prepare
-    - npmci npm install
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install stable 
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command npm run buildDocs
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true

.npmrc

@@ -0,0 +1 @@
+registry="https://registry.npmjs.org"

changelog.md

@@ -0,0 +1,71 @@
+# Changelog
+
+## 2025-05-26 - 2.1.2 - fix(documentation)
+Improve documentation formatting and code consistency across project files
+
+- Refined readme.md: replaced CI status badges with streamlined installation and usage instructions
+- Updated code formatting and whitespace in detector classes and interfaces for clarity
+- Enhanced test file formatting and adjusted options to improve test readability
+- Minor improvements in commit info data structure
+
+## 2025-05-26 - 2.1.1 - fix(detector)
+Improve test coverage and adjust detection result handling
+
+- Updated readme hints and plan to document the enhanced comprehensive test suite
+- Expanded tests to cover backward compatibility, performance benchmarks, and multiple service types
+- Modified detection logic to set serviceType to UNKNOWN when a port is inactive with detectServiceType option
+
+## 2025-05-26 - 2.1.0 - feat(detector)
+Enhance port detection and service fingerprinting with improved HTTP/HTTPS and SSH checks, update test scripts for verbose output, and revise documentation with new hints and a detailed improvement plan.
+
+- Updated package.json to use verbose testing and added '@git.zone/tsrun' dependency
+- Improved Detector class: finalized detectType implementation with protocol-specific checks and banner grabbing
+- Refined test cases to verify active ports and service detection for HTTP, HTTPS, and SSH
+- Expanded readme hints with project overview, key components, and detailed improvement plan
+
+## 2025-05-26 - 2.0.2 - fix(ci)
+Update CI workflows, dependency paths, and project configuration
+
+- Added new CI workflow files (.gitea/workflows/default_nottags.yaml and .gitea/workflows/default_tags.yaml) to replace the old GitLab CI configuration
+- Removed obsolete .gitlab-ci.yml file
+- Updated dependency import paths from '@pushrocks' to '@push.rocks' in source and commit info files
+- Revised package.json with new metadata fields and updated dependency versions
+- Enhanced tsconfig.json with decorator metadata and NodeNext module settings
+- Minor adjustments in .gitignore and readme formatting
+
+## 2022-07-16 - 2.0.1 - no significant changes
+This release was a version update only and did not include any relevant changes.
+
+- No noteworthy modifications.
+
+## 2022-07-16 - 2.0.0 - core
+fix(core): update
+
+- Updated core functionality.
+
+## 2022-07-16 - 1.0.5 - core
+BREAKING CHANGE(core): switch to esm
+
+- Switched to ES modules, introducing breaking changes.
+
+## 2022-07-16 - 1.0.4 - core
+fix(core): update
+
+- Updated core functionality.
+
+## 2021-04-14 - 1.0.3 - core
+fix(core): update
+
+- Updated core functionality.
+
+## 2021-04-13 - 1.0.2 - core
+fix(core): update
+
+- Updated core functionality.
+
+## 2021-04-12 - 1.0.1 - core
+fix(core): update
+
+- Updated core functionality.
+
+Other releases that were simple version bumps have been omitted from detailed descriptions.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uptime.link/detector",
-  "version": "1.0.5",
+  "version": "2.1.2",
   "private": false,
   "description": "a detector for answering network questions locally. It does not rely on any online services.",
   "main": "dist_ts/index.js",
@@ -9,22 +9,22 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
-    "test": "(tstest test/ --web)",
+    "test": "(tstest test/ --verbose)",
     "build": "(tsbuild --web --allowimplicitany)",
     "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.63",
+    "@git.zone/tsbuild": "^2.1.63",
-    "@gitzone/tsbundle": "^2.0.5",
+    "@git.zone/tsbundle": "^2.0.5",
-    "@gitzone/tstest": "^1.0.71",
+    "@git.zone/tsrun": "^1.3.3",
-    "@pushrocks/tapbundle": "^5.0.3",
+    "@git.zone/tstest": "^2.2.5",
-    "@types/node": "^18.0.5",
+    "@types/node": "^22.15.21",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.15.0"
   },
   "dependencies": {
-    "@pushrocks/smartnetwork": "^3.0.0",
+    "@push.rocks/smartnetwork": "^4.0.2",
-    "@pushrocks/smarturl": "^2.0.1"
+    "@push.rocks/smarturl": "^3.1.0"
   },
   "browserslist": [
     "last 1 chrome versions"
@@ -40,5 +40,16 @@
     "cli.js",
     "npmextra.json",
     "readme.md"
-  ]
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/uptime.link/detector.git"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/uptime.link/detector/issues"
+  },
+  "homepage": "https://gitlab.com/uptime.link/detector#readme",
+  "pnpm": {
+    "overrides": {}
+  }
 }

pnpm-workspace.yaml

@@ -0,0 +1,4 @@
+onlyBuiltDependencies:
+  - esbuild
+  - mongodb-memory-server
+  - puppeteer

readme.hints.md

@@ -0,0 +1,56 @@
+# Project Readme Hints
+
+## Project Overview
+- **@uptime.link/detector** - A network detection utility that checks port availability and service types locally
+- Version: 2.0.2 (recently updated from 2.0.1)
+- Type: ESM module (switched from CommonJS in v2.0.0)
+- Main purpose: Detect if ports are active/available and identify service types without external services
+
+## Key Components
+1. **Detector Class** (`ts/detector.classes.detector.ts`):
+   - `isActive(urlArg: string, options?: IDetectorOptions)`: Returns detailed IDetectorResult with service type detection
+   - `isActiveSimple(urlArg: string)`: Returns boolean for backward compatibility
+   - `detectType(urlArg: string)`: Detects service type (HTTP, HTTPS, SSH, FTP, etc.)
+   - For localhost: Uses `isLocalPortUnused()` (inverted to check if port is active)
+   - For remote: Uses `isRemotePortAvailable()`
+
+2. **Service Detection Features**:
+   - HTTP/HTTPS protocol detection with TLS support
+   - SSH service identification via banner detection
+   - Service fingerprinting for common protocols (FTP, SMTP, MySQL, etc.)
+   - Banner grabbing for unknown services
+   - Support for custom timeout configuration
+
+3. **Dependencies** (`ts/detector.plugins.ts`):
+   - `@push.rocks/smartnetwork`: Network utilities for port checking
+   - `@push.rocks/smarturl`: URL parsing utilities
+   - Node.js built-ins: net, tls, http, https for protocol detection
+
+4. **Interfaces** (`ts/detector.interfaces.ts`):
+   - `ServiceType`: Enum of supported service types
+   - `IDetectorResult`: Detailed result object with service info
+   - `IDetectorOptions`: Configuration options for detection
+
+## Recent Changes
+- **v2.0.0**: Breaking change - switched to ESM modules
+- **v2.0.1**: Minor update to commitinfo
+- **v2.0.2**: Added service type detection, protocol fingerprinting, and enhanced API
+
+## Testing
+- Comprehensive test suite with 19 tests covering:
+  - Basic port detection (local and remote)
+  - Backward compatibility with `isActiveSimple()`
+  - Service type detection for HTTP, HTTPS, SSH
+  - Error handling and edge cases
+  - Performance benchmarks
+  - Common development ports
+  - Database service detection (MySQL, Redis)
+- Uses `@git.zone/tstest` with tap-style testing
+- Tests ensure serviceType is always returned when detectServiceType option is true
+- Handles non-standard URL schemes with default ports
+
+## Notes
+- Project uses pnpm for package management
+- Build supports web targets (`--web` flag)
+- No external online services required for detection
+- All network detection happens locally without third-party APIs

readme.md

@@ -1,32 +1,171 @@
 # @uptime.link/detector
+
 a detector for answering network questions locally. It does not rely on any online services.
 
 ## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@uptime.link/detector)
-* [gitlab.com (source)](https://gitlab.com/uptime.link/detector)
-* [github.com (source mirror)](https://github.com/uptime.link/detector)
-* [docs (typedoc)](https://uptime.link.gitlab.io/detector/)
 
-## Status for master
+- [npmjs.org (npm package)](https://www.npmjs.com/package/@uptime.link/detector)
+- [gitlab.com (source)](https://gitlab.com/uptime.link/detector)
+- [github.com (source mirror)](https://github.com/uptime.link/detector)
+- [docs (typedoc)](https://uptime.link.gitlab.io/detector/)
 
-Status Category | Status Badge
+## Installation
--- | --
+
-GitLab Pipelines | [![pipeline status](https://gitlab.com/uptime.link/detector/badges/master/pipeline.svg)](https://lossless.cloud)
+```bash
-GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/uptime.link/detector/badges/master/coverage.svg)](https://lossless.cloud)
+npm install @uptime.link/detector
-npm | [![npm downloads per month](https://badgen.net/npm/dy/@uptime.link/detector)](https://lossless.cloud)
+```
-Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/uptime.link/detector)](https://lossless.cloud)
-TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
-node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
-PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@uptime.link/detector)](https://lossless.cloud)
-PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@uptime.link/detector)](https://lossless.cloud)
-BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@uptime.link/detector)](https://lossless.cloud)
-Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
 
 ## Usage
 
 Use TypeScript for best in class intellisense
 
+### Basic Port Detection
+
+```typescript
+import { Detector } from '@uptime.link/detector';
+
+const detector = new Detector();
+
+// Check if a port is active (returns detailed result)
+const result = await detector.isActive('https://example.com');
+console.log(result.isActive); // true
+
+// Simple boolean check (backward compatible)
+const isActive = await detector.isActiveSimple('https://example.com');
+console.log(isActive); // true
+```
+
+### Service Type Detection
+
+The detector can identify what service is running on a port:
+
+```typescript
+// Detect service type along with port check
+const result = await detector.isActive('https://github.com', {
+  detectServiceType: true,
+});
+
+console.log(result.isActive); // true
+console.log(result.serviceType); // 'https'
+
+// Direct service type detection
+const serviceType = await detector.detectType('ssh://github.com:22');
+console.log(serviceType); // 'ssh'
+```
+
+### Supported Service Types
+
+The detector can identify the following services:
+
+- **HTTP** (port 80)
+- **HTTPS** (port 443)
+- **SSH** (port 22)
+- **FTP** (port 21)
+- **SMTP** (port 25)
+- **POP3** (port 110)
+- **IMAP** (port 143)
+- **MySQL** (port 3306)
+- **PostgreSQL** (port 5432)
+- **MongoDB** (port 27017)
+- **Redis** (port 6379)
+- **Unknown** (for unidentified services)
+
+### Advanced Examples
+
+```typescript
+// Check localhost ports
+const localResult = await detector.isActive('http://localhost:3000', {
+  detectServiceType: true,
+});
+
+if (localResult.isActive) {
+  console.log(`Local service detected: ${localResult.serviceType}`);
+}
+
+// Check multiple services
+const urls = ['https://api.github.com', 'http://example.com', 'ssh://gitlab.com:22'];
+
+for (const url of urls) {
+  const result = await detector.isActive(url, { detectServiceType: true });
+  console.log(`${url}: ${result.isActive ? result.serviceType : 'offline'}`);
+}
+
+// Handle different URL schemes with automatic port detection
+const sshDetection = await detector.detectType('ssh://github.com');
+// Automatically uses port 22 for SSH
+
+const mysqlDetection = await detector.detectType('mysql://localhost');
+// Automatically uses port 3306 for MySQL
+```
+
+### API Reference
+
+#### `Detector`
+
+The main class for network detection.
+
+##### Methods
+
+- **`isActive(url: string, options?: IDetectorOptions): Promise<IDetectorResult>`**
+
+  - Checks if a port is active and optionally detects the service type
+  - Returns detailed information about the port status and service
+
+- **`isActiveSimple(url: string): Promise<boolean>`**
+
+  - Simple boolean check for backward compatibility
+  - Returns `true` if port is active, `false` otherwise
+
+- **`detectType(url: string): Promise<ServiceType>`**
+  - Detects the service type running on the specified URL
+  - Uses protocol-specific detection methods and banner grabbing
+
+#### Interfaces
+
+```typescript
+interface IDetectorResult {
+  isActive: boolean;
+  serviceType?: ServiceType;
+  protocol?: 'tcp' | 'udp';
+  responseTime?: number;
+  tlsVersion?: string;
+  serviceBanner?: string;
+  error?: string;
+}
+
+interface IDetectorOptions {
+  timeout?: number;
+  includeNetworkDiagnostics?: boolean;
+  detectServiceType?: boolean;
+}
+
+enum ServiceType {
+  HTTP = 'http',
+  HTTPS = 'https',
+  SSH = 'ssh',
+  FTP = 'ftp',
+  SMTP = 'smtp',
+  POP3 = 'pop3',
+  IMAP = 'imap',
+  MYSQL = 'mysql',
+  POSTGRESQL = 'postgresql',
+  MONGODB = 'mongodb',
+  REDIS = 'redis',
+  UNKNOWN = 'unknown',
+}
+```
+
+## Features
+
+- ✅ **Local Network Detection** - Check ports on localhost without external services
+- ✅ **Remote Port Detection** - Verify if remote ports are accessible
+- ✅ **Service Identification** - Detect what service is running on a port
+- ✅ **Protocol Detection** - Identify HTTP/HTTPS and other protocols
+- ✅ **Banner Grabbing** - Extract service information from response banners
+- ✅ **TypeScript Support** - Full type definitions included
+- ✅ **ESM Module** - Modern ES module support
+- ✅ **No External Dependencies** - All detection happens locally
+
 ## Contribution
 
 We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
@@ -34,6 +173,6 @@ We are always happy for code contributions. If you are not the code contributing
 For further information read the linked docs at the top of this readme.
 
 > MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
 
 [![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

readme.plan.md

@@ -0,0 +1,69 @@
+# Detector Module Improvement Plan
+
+Command to reread CLAUDE.md: `cat ~/.claude/CLAUDE.md`
+
+## Current State
+- Only detects if ports are active/available
+- Has unimplemented `detectType()` method
+
+## Proposed Improvements
+
+### 1. Implement `detectType()` method
+- Detect service type running on port (HTTP, HTTPS, SSH, FTP, etc.)
+- Use protocol-specific handshakes without external services
+
+### 2. Add Network Interface Detection
+- List local network interfaces
+- Get IP addresses, MAC addresses
+- Detect network connectivity status
+
+### 3. Add Local DNS Capabilities
+- Resolve hostnames using local DNS
+- Check DNS configuration
+- Detect local DNS servers
+
+### 4. Add Protocol Detection
+- HTTP/HTTPS detection with TLS version
+- WebSocket support detection
+- TCP/UDP differentiation
+
+### 5. Add Network Diagnostics
+- Ping functionality (ICMP)
+- Traceroute capabilities
+- MTU discovery
+- Network latency measurement
+
+### 6. Add Service Fingerprinting
+- Identify common services by banner grabbing
+- Detect service versions locally
+- Support for common protocols (SSH, FTP, SMTP, etc.)
+
+### 7. Add Local Network Discovery
+- Discover devices on local network
+- ARP scanning for local subnet
+- mDNS/Bonjour service discovery
+
+### 8. Enhance API
+- Add batch checking for multiple URLs/ports
+- Add timeout configuration
+- Add detailed response objects with metadata
+
+## Implementation Priority
+1. ✅ Implement `detectType()` - COMPLETED
+2. ✅ Add protocol detection for HTTP/HTTPS - COMPLETED
+3. ✅ Add service fingerprinting - COMPLETED (basic version)
+4. ✅ Create enhanced API with IDetectorResult - COMPLETED
+5. Add network diagnostics - TODO
+6. Add local network discovery - TODO
+7. Add batch operations - TODO
+
+## What Was Implemented
+- ✅ `detectType()` method with protocol-specific detection
+- ✅ HTTP/HTTPS detection with proper protocol handling
+- ✅ SSH service detection via banner
+- ✅ Service fingerprinting for common protocols (FTP, SMTP, MySQL, etc.)
+- ✅ IDetectorResult interface for detailed responses
+- ✅ IDetectorOptions for configuration
+- ✅ Backward compatibility with `isActiveSimple()` method
+- ✅ Banner grabbing for unknown services
+- ✅ Tests for new functionality - IMPROVED with comprehensive test suite (19 tests)

test/test.ts

@@ -1,21 +1,151 @@
-import { expect, tap } from '@pushrocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as detector from '../ts/index.js';
 
 let testDetector: detector.Detector;
 
-tap.test('first test', async () => {
+tap.test('should create a detector instance', async () => {
   testDetector = new detector.Detector();
   expect(testDetector).toBeInstanceOf(detector.Detector);
 });
 
-tap.test('should detect an closed port on a local domain', async () => {
+// Basic port detection tests
+tap.test('should detect a closed port on localhost', async () => {
   const result = await testDetector.isActive('http://localhost:3008');
-  expect(result).toBeFalse();
+  expect(result.isActive).toBeFalse();
+  expect(result.serviceType).toBeUndefined();
 });
 
 tap.test('should detect an open port on a remote domain', async () => {
   const result = await testDetector.isActive('https://lossless.com');
+  expect(result.isActive).toBeTrue();
+});
+
+// Backward compatibility tests
+tap.test('should support backward compatibility with isActiveSimple', async () => {
+  const result = await testDetector.isActiveSimple('https://example.com');
+  expect(result).toBeTypeofBoolean();
   expect(result).toBeTrue();
 });
 
-tap.start();
+tap.test('should return false for closed port with isActiveSimple', async () => {
+  const result = await testDetector.isActiveSimple('http://localhost:3008');
+  expect(result).toBeFalse();
+});
+
+// Service detection tests
+tap.test('should detect HTTP service on port 80', async () => {
+  const result = await testDetector.isActive('http://example.com', { detectServiceType: true });
+  expect(result.isActive).toBeTrue();
+  expect(result.serviceType).toEqual(detector.ServiceType.HTTP);
+});
+
+tap.test('should detect HTTPS service on port 443', async () => {
+  const result = await testDetector.isActive('https://example.com', { detectServiceType: true });
+  expect(result.isActive).toBeTrue();
+  expect(result.serviceType).toEqual(detector.ServiceType.HTTPS);
+});
+
+tap.test('should detect SSH service on GitHub', async () => {
+  const sshType = await testDetector.detectType('ssh://github.com:22');
+  expect(sshType).toEqual(detector.ServiceType.SSH);
+});
+
+tap.test('should detect HTTPS on non-standard port', async () => {
+  const result = await testDetector.isActive('https://lossless.com:443', {
+    detectServiceType: true,
+  });
+  if (result.isActive) {
+    expect(result.serviceType).toEqual(detector.ServiceType.HTTPS);
+  }
+});
+
+// Direct detectType tests
+tap.test('should detect common services by port number', async () => {
+  // Test FTP port
+  const ftpType = await testDetector.detectType('ftp://localhost:21');
+  // Since localhost:21 is likely not running, it will try detection
+  expect(ftpType).toBeTypeofString();
+});
+
+tap.test('should return UNKNOWN for non-standard ports', async () => {
+  const result = await testDetector.isActive('http://localhost:9999', { detectServiceType: true });
+  if (result.isActive) {
+    expect(result.serviceType).toEqual(detector.ServiceType.UNKNOWN);
+  }
+});
+
+// Edge cases
+tap.test('should handle invalid URLs gracefully', async () => {
+  try {
+    await testDetector.isActive('not-a-valid-url');
+  } catch (error) {
+    expect(error).toBeInstanceOf(Error);
+  }
+});
+
+tap.test('should handle localhost with detectServiceType', async () => {
+  const result = await testDetector.isActive('http://localhost:8080', { detectServiceType: true });
+  expect(result).toHaveProperty('isActive');
+  expect(result).toHaveProperty('serviceType');
+});
+
+// Multiple service checks
+tap.test('should correctly identify multiple HTTPS services', async () => {
+  const services = [
+    { url: 'https://google.com', expected: detector.ServiceType.HTTPS },
+    { url: 'https://github.com', expected: detector.ServiceType.HTTPS },
+  ];
+
+  for (const service of services) {
+    const result = await testDetector.isActive(service.url, { detectServiceType: true });
+    if (result.isActive) {
+      expect(result.serviceType).toEqual(service.expected);
+    }
+  }
+});
+
+// Performance test
+tap.test('should complete detection within reasonable time', async () => {
+  const startTime = Date.now();
+  await testDetector.isActive('https://example.com', { detectServiceType: true });
+  const duration = Date.now() - startTime;
+  // Should complete within 10 seconds
+  expect(duration).toBeLessThan(10000);
+});
+
+// Test without service detection
+tap.test('should work without service detection option', async () => {
+  const result = await testDetector.isActive('https://example.com');
+  expect(result.isActive).toBeTrue();
+  expect(result.serviceType).toBeUndefined();
+});
+
+// Test specific ports
+tap.test('should handle MySQL default port', async () => {
+  const mysqlType = await testDetector.detectType('mysql://localhost:3306');
+  // Will return MYSQL based on port, but actual detection depends on service running
+  expect([detector.ServiceType.MYSQL, detector.ServiceType.UNKNOWN]).toContain(mysqlType);
+});
+
+tap.test('should handle Redis default port', async () => {
+  const redisType = await testDetector.detectType('redis://localhost:6379');
+  expect([detector.ServiceType.REDIS, detector.ServiceType.UNKNOWN]).toContain(redisType);
+});
+
+// Local port tests
+tap.test('should detect commonly used local development ports', async () => {
+  const localPorts = [
+    { url: 'http://localhost:3000', name: 'Node.js dev server' },
+    { url: 'http://localhost:4200', name: 'Angular dev server' },
+    { url: 'http://localhost:8080', name: 'Common web server' },
+  ];
+
+  for (const port of localPorts) {
+    const result = await testDetector.isActive(port.url);
+    // Just check that it returns a valid result structure
+    expect(result).toHaveProperty('isActive');
+    expect(result.isActive).toBeTypeofBoolean();
+  }
+});
+
+export default tap.start();

ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@uptime.link/detector',
-  version: '1.0.5',
+  version: '2.1.2',
   description: 'a detector for answering network questions locally. It does not rely on any online services.'
 }

ts/detector.classes.detector.ts

@@ -1,28 +1,262 @@
 import * as plugins from './detector.plugins.js';
+import { ServiceType } from './detector.interfaces.js';
+import type { IDetectorResult, IDetectorOptions } from './detector.interfaces.js';
 
 export class Detector {
   private smartnetworkInstance = new plugins.smartnetwork.SmartNetwork();
 
-  public async isActive(urlArg: string): Promise<boolean> {
+  /**
+   * Check if a port is active - simple boolean version for backward compatibility
+   */
+  public async isActiveSimple(urlArg: string): Promise<boolean> {
+    const result = await this.isActive(urlArg);
+    return result.isActive;
+  }
+
+  /**
+   * Check if a port is active with detailed results
+   */
+  public async isActive(urlArg: string, options?: IDetectorOptions): Promise<IDetectorResult> {
     const parsedUrl = plugins.smarturl.Smarturl.createFromUrl(urlArg);
     if (parsedUrl.hostname === 'localhost') {
       console.log(`detector target is localhost on port ${parsedUrl.port}`);
       const portUnused = await this.smartnetworkInstance.isLocalPortUnused(
-        parseInt(parsedUrl.port, 10)
+        parseInt(parsedUrl.port, 10),
       );
       const portAvailable = !portUnused;
-      return portAvailable;
+
+      const result: IDetectorResult = {
+        isActive: portAvailable,
+      };
+
+      if (options?.detectServiceType) {
+        if (portAvailable) {
+          const serviceType = await this.detectType(urlArg);
+          result.serviceType = serviceType;
         } else {
-      console.log(`detector target is remote domain ${parsedUrl.host} on port ${parsedUrl.port}`);
+          result.serviceType = ServiceType.UNKNOWN;
-      const postAvailable = await this.smartnetworkInstance.isRemotePortAvailable(
-        parsedUrl.host,
-        parseInt(parsedUrl.port, 10)
-      );
-      return postAvailable;
         }
       }
 
-  public detectType(urlArg: string) {
+      return result;
-    console.log('TODO'); // TODO
+    } else {
+      console.log(`detector target is remote domain ${parsedUrl.host} on port ${parsedUrl.port}`);
+      const portAvailable = await this.smartnetworkInstance.isRemotePortAvailable(
+        parsedUrl.host,
+        parseInt(parsedUrl.port, 10),
+      );
+
+      const result: IDetectorResult = {
+        isActive: portAvailable,
+      };
+
+      if (options?.detectServiceType) {
+        if (portAvailable) {
+          const serviceType = await this.detectType(urlArg);
+          result.serviceType = serviceType;
+        } else {
+          result.serviceType = ServiceType.UNKNOWN;
+        }
+      }
+
+      return result;
+    }
+  }
+
+  public async detectType(urlArg: string): Promise<ServiceType> {
+    const parsedUrl = plugins.smarturl.Smarturl.createFromUrl(urlArg);
+
+    // Handle different URL schemes and default ports
+    let port = parseInt(parsedUrl.port, 10);
+    if (isNaN(port)) {
+      // Set default ports based on scheme
+      const defaultPorts: { [key: string]: number } = {
+        http: 80,
+        https: 443,
+        ssh: 22,
+        ftp: 21,
+        smtp: 25,
+        mysql: 3306,
+        postgresql: 5432,
+        mongodb: 27017,
+        redis: 6379,
+      };
+
+      const scheme = parsedUrl.protocol.replace(':', '').toLowerCase();
+      port = defaultPorts[scheme] || 80;
+    }
+
+    const hostname = parsedUrl.hostname;
+
+    // Check common ports first
+    const commonPorts: { [key: number]: ServiceType } = {
+      80: ServiceType.HTTP,
+      443: ServiceType.HTTPS,
+      22: ServiceType.SSH,
+      21: ServiceType.FTP,
+      25: ServiceType.SMTP,
+      110: ServiceType.POP3,
+      143: ServiceType.IMAP,
+      3306: ServiceType.MYSQL,
+      5432: ServiceType.POSTGRESQL,
+      27017: ServiceType.MONGODB,
+      6379: ServiceType.REDIS,
+    };
+
+    if (commonPorts[port]) {
+      // Verify the service is actually what we expect
+      const verified = await this.verifyServiceType(hostname, port, commonPorts[port]);
+      if (verified) {
+        return commonPorts[port];
+      }
+    }
+
+    // Try to detect service by banner/protocol
+    return await this.detectServiceByProtocol(hostname, port);
+  }
+
+  private async verifyServiceType(
+    hostname: string,
+    port: number,
+    expectedType: ServiceType,
+  ): Promise<boolean> {
+    try {
+      switch (expectedType) {
+        case ServiceType.HTTP:
+        case ServiceType.HTTPS:
+          return await this.checkHttpService(hostname, port, expectedType === ServiceType.HTTPS);
+        case ServiceType.SSH:
+          return await this.checkSshService(hostname, port);
+        default:
+          return true; // For now, trust the port number for other services
+      }
+    } catch (error) {
+      return false;
+    }
+  }
+
+  private async detectServiceByProtocol(hostname: string, port: number): Promise<ServiceType> {
+    // Try HTTPS first
+    if (await this.checkHttpService(hostname, port, true)) {
+      return ServiceType.HTTPS;
+    }
+
+    // Try HTTP
+    if (await this.checkHttpService(hostname, port, false)) {
+      return ServiceType.HTTP;
+    }
+
+    // Try SSH
+    if (await this.checkSshService(hostname, port)) {
+      return ServiceType.SSH;
+    }
+
+    // Try to get banner for other services
+    const banner = await this.getBanner(hostname, port);
+    if (banner) {
+      return this.identifyServiceByBanner(banner);
+    }
+
+    return ServiceType.UNKNOWN;
+  }
+
+  private async checkHttpService(
+    hostname: string,
+    port: number,
+    isHttps: boolean,
+  ): Promise<boolean> {
+    return new Promise((resolve) => {
+      const protocol = isHttps ? plugins.https : plugins.http;
+      const options = {
+        hostname,
+        port,
+        method: 'HEAD',
+        timeout: 5000,
+        rejectUnauthorized: false, // Accept self-signed certificates
+      };
+
+      const req = protocol.request(options, () => {
+        resolve(true);
+      });
+
+      req.on('error', () => {
+        resolve(false);
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(false);
+      });
+
+      req.end();
+    });
+  }
+
+  private async checkSshService(hostname: string, port: number): Promise<boolean> {
+    return new Promise((resolve) => {
+      const socket = new plugins.net.Socket();
+
+      socket.setTimeout(5000);
+
+      socket.on('data', (data) => {
+        const banner = data.toString();
+        socket.destroy();
+        // SSH banners typically start with "SSH-"
+        resolve(banner.startsWith('SSH-'));
+      });
+
+      socket.on('error', () => {
+        resolve(false);
+      });
+
+      socket.on('timeout', () => {
+        socket.destroy();
+        resolve(false);
+      });
+
+      socket.connect(port, hostname);
+    });
+  }
+
+  private async getBanner(hostname: string, port: number): Promise<string | null> {
+    return new Promise((resolve) => {
+      const socket = new plugins.net.Socket();
+      let banner = '';
+
+      socket.setTimeout(5000);
+
+      socket.on('data', (data) => {
+        banner += data.toString();
+        socket.destroy();
+        resolve(banner);
+      });
+
+      socket.on('error', () => {
+        resolve(null);
+      });
+
+      socket.on('timeout', () => {
+        socket.destroy();
+        resolve(banner || null);
+      });
+
+      socket.connect(port, hostname);
+    });
+  }
+
+  private identifyServiceByBanner(banner: string): ServiceType {
+    const bannerLower = banner.toLowerCase();
+
+    if (bannerLower.includes('ssh')) return ServiceType.SSH;
+    if (bannerLower.includes('ftp')) return ServiceType.FTP;
+    if (bannerLower.includes('smtp')) return ServiceType.SMTP;
+    if (bannerLower.includes('pop3')) return ServiceType.POP3;
+    if (bannerLower.includes('imap')) return ServiceType.IMAP;
+    if (bannerLower.includes('mysql')) return ServiceType.MYSQL;
+    if (bannerLower.includes('postgresql')) return ServiceType.POSTGRESQL;
+    if (bannerLower.includes('mongodb')) return ServiceType.MONGODB;
+    if (bannerLower.includes('redis')) return ServiceType.REDIS;
+
+    return ServiceType.UNKNOWN;
   }
 }

ts/detector.interfaces.ts

@@ -0,0 +1,44 @@
+export enum ServiceType {
+  HTTP = 'http',
+  HTTPS = 'https',
+  SSH = 'ssh',
+  FTP = 'ftp',
+  SMTP = 'smtp',
+  POP3 = 'pop3',
+  IMAP = 'imap',
+  MYSQL = 'mysql',
+  POSTGRESQL = 'postgresql',
+  MONGODB = 'mongodb',
+  REDIS = 'redis',
+  UNKNOWN = 'unknown',
+}
+
+export interface IDetectorResult {
+  isActive: boolean;
+  serviceType?: ServiceType;
+  protocol?: 'tcp' | 'udp';
+  responseTime?: number;
+  tlsVersion?: string;
+  serviceBanner?: string;
+  error?: string;
+}
+
+export interface INetworkDiagnostics {
+  ping?: {
+    reachable: boolean;
+    averageLatency: number;
+    packetLoss: number;
+  };
+  traceroute?: Array<{
+    hop: number;
+    hostname: string;
+    ip: string;
+    latency: number;
+  }>;
+}
+
+export interface IDetectorOptions {
+  timeout?: number;
+  includeNetworkDiagnostics?: boolean;
+  detectServiceType?: boolean;
+}

ts/detector.plugins.ts

@@ -1,5 +1,11 @@
-// pushrocks scope
+// node native
-import * as smartnetwork from '@pushrocks/smartnetwork';
+import * as net from 'net';
-import * as smarturl from '@pushrocks/smarturl';
+import * as tls from 'tls';
+import * as http from 'http';
+import * as https from 'https';
 
-export { smartnetwork, smarturl };
+// pushrocks scope
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import * as smarturl from '@push.rocks/smarturl';
+
+export { net, tls, http, https, smartnetwork, smarturl };

ts/index.ts

@@ -1 +1,2 @@
 export * from './detector.classes.detector.js';
+export * from './detector.interfaces.js';

tsconfig.json

@@ -1,10 +1,17 @@
 {
   "compilerOptions": {
     "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "useDefineForClassFields": false,
     "target": "ES2022",
-    "module": "ES2022",
+    "module": "NodeNext",
-    "moduleResolution": "nodenext",
+    "moduleResolution": "NodeNext",
-    "esModuleInterop": true
+    "esModuleInterop": true,
-  }
+    "verbatimModuleSyntax": true,
+    "baseUrl": ".",
+    "paths": {}
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
 }