push.rocks/smartproxy
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(docs): update README with installation, improved feature table, expanded quick-start, ACME/email example, API options interface, and clarified licensing/trademark text

Browse Source
This commit is contained in:
Jürgen Kunz
2026-01-30 09:22:41 +00:00
parent 90e8f92e86
commit 9b1adb1d7a
3 changed files with 246 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
changelog.md
View File

@@ -1,5 +1,15 @@
# Changelog # Changelog
## 2026-01-30 - 22.3.0 - feat(docs)
update README with installation, improved feature table, expanded quick-start, ACME/email example, API options interface, and clarified licensing/trademark text
- Added Installation section with npm/pnpm commands
- Reformatted features into a markdown table for clarity
- Expanded Quick Start example and updated ACME email placeholder
- Added an ISmartProxyOptions interface example showing acme/defaults/behavior options
- Clarified license file path and expanded trademark/legal wording
- Minor editorial and formatting improvements throughout the README
## 2026-01-30 - 22.2.0 - feat(proxies) ## 2026-01-30 - 22.2.0 - feat(proxies)
introduce nftables command executor and utilities, default certificate provider, expanded route/socket helper modules, and security improvements introduce nftables command executor and utilities, default certificate provider, expanded route/socket helper modules, and security improvements

407
readme.md
View File

@@ -2,32 +2,40 @@
**The Swiss Army Knife of Node.js Proxies** - A unified, high-performance proxy toolkit that handles everything from simple HTTP forwarding to complex enterprise routing scenarios. **The Swiss Army Knife of Node.js Proxies** - A unified, high-performance proxy toolkit that handles everything from simple HTTP forwarding to complex enterprise routing scenarios.
## 📦 Installation
```bash
npm install @push.rocks/smartproxy
# or
pnpm add @push.rocks/smartproxy
```
## Issue Reporting and Security
For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
## 🎯 What is SmartProxy? ## 🎯 What is SmartProxy?
SmartProxy is a modern, production-ready proxy solution that brings order to the chaos of traffic management. Whether you're building microservices, deploying edge infrastructure, or need a battle-tested reverse proxy, SmartProxy has you covered. SmartProxy is a modern, production-ready proxy solution that brings order to the chaos of traffic management. Whether you're building microservices, deploying edge infrastructure, or need a battle-tested reverse proxy, SmartProxy has you covered.
### ⚡ Key Features ### ⚡ Key Features
- **🔀 Unified Route-Based Configuration** - Clean match/action patterns for intuitive traffic routing | Feature | Description |
- **🔒 Automatic SSL/TLS with Let's Encrypt** - Zero-config HTTPS with automatic certificate provisioning |---------|-------------|
- **🎯 Flexible Matching Patterns** - Route by port, domain, path, client IP, TLS version, or custom logic | 🔀 **Unified Route-Based Config** | Clean match/action patterns for intuitive traffic routing |
- **🚄 High-Performance Forwarding** - Choose between user-space or kernel-level (NFTables) forwarding | 🔒 **Automatic SSL/TLS** | Zero-config HTTPS with Let's Encrypt ACME integration |
- **⚖️ Built-in Load Balancing** - Distribute traffic across multiple backends with health checks | 🎯 **Flexible Matching** | Route by port, domain, path, client IP, TLS version, or custom logic |
- **🛡️ Enterprise Security** - IP filtering, rate limiting, authentication, and connection limits | 🚄 **High-Performance** | Choose between user-space or kernel-level (NFTables) forwarding |
- **🔌 WebSocket Support** - First-class WebSocket proxying with ping/pong management | ⚖️ **Load Balancing** | Distribute traffic with health checks and multiple algorithms |
- **🎮 Custom Socket Handlers** - Implement any protocol with full socket control | 🛡️ **Enterprise Security** | IP filtering, rate limiting, authentication, connection limits |
- **📊 Dynamic Port Management** - Add/remove ports at runtime without restarts | 🔌 **WebSocket Support** | First-class WebSocket proxying with ping/pong keep-alive |
- **🔧 Protocol Detection** - Smart protocol detection for mixed-mode operation | 🎮 **Custom Protocols** | Socket handlers for implementing any protocol |
| 📊 **Live Metrics** | Real-time throughput, connection counts, and performance data |
## 📦 Installation | 🔧 **Dynamic Management** | Add/remove ports and routes at runtime without restarts |
```bash
npm install @push.rocks/smartproxy
```
## 🚀 Quick Start ## 🚀 Quick Start
Let's get you up and running in 30 seconds: Get up and running in 30 seconds:
```typescript ```typescript
import { SmartProxy, createCompleteHttpsServer } from '@push.rocks/smartproxy'; import { SmartProxy, createCompleteHttpsServer } from '@push.rocks/smartproxy';
@@ -35,14 +43,14 @@ import { SmartProxy, createCompleteHttpsServer } from '@push.rocks/smartproxy';
// Create a proxy with automatic HTTPS // Create a proxy with automatic HTTPS
const proxy = new SmartProxy({ const proxy = new SmartProxy({
acme: { acme: {
email: 'ssl@example.com', // Your email for Let's Encrypt email: 'ssl@yourdomain.com', // Your email for Let's Encrypt
useProduction: true // Use Let's Encrypt production servers useProduction: true // Use production servers
}, },
routes: [ routes: [
// Complete HTTPS setup with one line // Complete HTTPS setup in one line! ✨
...createCompleteHttpsServer('app.example.com', { ...createCompleteHttpsServer('app.example.com', {
host: 'localhost', host: 'localhost',
port: 3000 port: 3000
}, { }, {
certificate: 'auto' // Magic! 🎩 certificate: 'auto' // Magic! 🎩
}) })
@@ -57,10 +65,11 @@ console.log('🚀 Proxy running with automatic HTTPS!');
### 🏗️ Route-Based Architecture ### 🏗️ Route-Based Architecture
SmartProxy uses a powerful match/action pattern that makes routing predictable and maintainable: SmartProxy uses a powerful **match/action** pattern that makes routing predictable and maintainable:
```typescript ```typescript
{ {
name: 'api-route',
match: { match: {
ports: 443, ports: 443,
domains: 'api.example.com', domains: 'api.example.com',
@@ -74,22 +83,31 @@ SmartProxy uses a powerful match/action pattern that makes routing predictable a
} }
``` ```
Every route has: Every route consists of:
- **Match criteria** - What traffic to capture - **Match** - What traffic to capture (ports, domains, paths, IPs)
- **Action** - What to do with it - **Action** - What to do with it (forward, redirect, block, socket-handler)
- **Security** (optional) - Access controls and limits - **Security** (optional) - Access controls, rate limits, authentication
- **Metadata** (optional) - Name, priority, tags - **Name/Priority** (optional) - For identification and ordering
### 🔄 TLS Modes
SmartProxy supports three TLS handling modes:
| Mode | Description | Use Case |
|------|-------------|----------|
| `passthrough` | Forward encrypted traffic as-is | Backend handles TLS |
| `terminate` | Decrypt at proxy, forward plain | Standard reverse proxy |
| `terminate-and-reencrypt` | Decrypt, then re-encrypt to backend | Zero-trust environments |
## 💡 Common Use Cases ## 💡 Common Use Cases
### 🌐 Simple HTTP to HTTPS Redirect ### 🌐 HTTP to HTTPS Redirect
```typescript ```typescript
import { SmartProxy, createHttpToHttpsRedirect } from '@push.rocks/smartproxy'; import { SmartProxy, createHttpToHttpsRedirect } from '@push.rocks/smartproxy';
const proxy = new SmartProxy({ const proxy = new SmartProxy({
routes: [ routes: [
// Redirect all HTTP traffic to HTTPS
createHttpToHttpsRedirect(['example.com', '*.example.com']) createHttpToHttpsRedirect(['example.com', '*.example.com'])
] ]
}); });
@@ -133,7 +151,8 @@ const route = createWebSocketRoute(
path: '/socket', path: '/socket',
useTls: true, useTls: true,
certificate: 'auto', certificate: 'auto',
pingInterval: 30000 // Keep connections alive pingInterval: 30000, // Keep connections alive
pingTimeout: 10000
} }
); );
``` ```
@@ -154,51 +173,64 @@ let route = createApiGatewayRoute(
} }
); );
// Add rate limiting // Add rate limiting - 100 requests per minute per IP
route = addRateLimiting(route, { route = addRateLimiting(route, {
maxRequests: 100, maxRequests: 100,
window: 60, // seconds window: 60,
keyBy: 'ip' keyBy: 'ip'
}); });
``` ```
### 🎮 Custom Protocol Handler ### 🎮 Custom Protocol Handler
SmartProxy lets you implement any protocol with full socket control:
```typescript ```typescript
import { createSocketHandlerRoute, SocketHandlers } from '@push.rocks/smartproxy'; import { createSocketHandlerRoute, SocketHandlers } from '@push.rocks/smartproxy';
// Pre-built handlers // Use pre-built handlers
const echoRoute = createSocketHandlerRoute( const echoRoute = createSocketHandlerRoute(
'echo.example.com', 'echo.example.com',
7777, 7777,
SocketHandlers.echo SocketHandlers.echo
); );
// Custom handler // Or create your own custom protocol
const customRoute = createSocketHandlerRoute( const customRoute = createSocketHandlerRoute(
'custom.example.com', 'custom.example.com',
9999, 9999,
async (socket, context) => { async (socket, context) => {
console.log(`Connection from ${context.clientIp}`); console.log(`Connection from ${context.clientIp}`);
socket.write('Welcome to my custom protocol!\n'); socket.write('Welcome to my custom protocol!\n');
socket.on('data', (data) => { socket.on('data', (data) => {
const command = data.toString().trim(); const command = data.toString().trim();
switch (command) {
if (command === 'HELLO') { case 'PING': socket.write('PONG\n'); break;
socket.write('World!\n'); case 'TIME': socket.write(`${new Date().toISOString()}\n`); break;
} else if (command === 'EXIT') { case 'QUIT': socket.end('Goodbye!\n'); break;
socket.end('Goodbye!\n'); default: socket.write(`Unknown: ${command}\n`);
} }
}); });
} }
); );
``` ```
**Pre-built Socket Handlers:**
| Handler | Description |
|---------|-------------|
| `SocketHandlers.echo` | Echo server - returns everything sent |
| `SocketHandlers.proxy(host, port)` | TCP proxy to another server |
| `SocketHandlers.lineProtocol(handler)` | Line-based text protocol |
| `SocketHandlers.httpResponse(code, body)` | Simple HTTP response |
| `SocketHandlers.httpRedirect(url, code)` | HTTP redirect with templates |
| `SocketHandlers.httpServer(handler)` | Full HTTP request/response handling |
| `SocketHandlers.block(message)` | Block with optional message |
### ⚡ High-Performance NFTables Forwarding ### ⚡ High-Performance NFTables Forwarding
For ultra-low latency, use kernel-level forwarding (Linux only, requires root): For ultra-low latency on Linux, use kernel-level forwarding (requires root):
```typescript ```typescript
import { createNfTablesTerminateRoute } from '@push.rocks/smartproxy'; import { createNfTablesTerminateRoute } from '@push.rocks/smartproxy';
@@ -209,8 +241,8 @@ const route = createNfTablesTerminateRoute(
{ {
ports: 443, ports: 443,
certificate: 'auto', certificate: 'auto',
preserveSourceIP: true, preserveSourceIP: true, // Backend sees real client IP
maxRate: '1gbps' maxRate: '1gbps' // QoS rate limiting
} }
); );
``` ```
@@ -223,21 +255,18 @@ Route traffic based on runtime conditions:
```typescript ```typescript
{ {
name: 'business-hours-only',
match: { match: {
ports: 443, ports: 443,
customMatcher: async (context) => { domains: 'internal.example.com'
// Route based on time of day
const hour = new Date().getHours();
return hour >= 9 && hour < 17; // Business hours only
}
}, },
action: { action: {
type: 'forward', type: 'forward',
targets: [{ targets: [{
host: (context) => { host: (context) => {
// Dynamic host selection // Dynamic host selection based on path
return context.path.startsWith('/premium') return context.path?.startsWith('/premium')
? 'premium-backend' ? 'premium-backend'
: 'standard-backend'; : 'standard-backend';
}, },
port: 8080 port: 8080
@@ -248,30 +277,29 @@ Route traffic based on runtime conditions:
### 🔒 Security Controls ### 🔒 Security Controls
Comprehensive security options per route: Comprehensive per-route security options:
```typescript ```typescript
{ {
name: 'secure-api',
match: { ports: 443, domains: 'api.example.com' },
action: {
type: 'forward',
targets: [{ host: 'api-backend', port: 8080 }]
},
security: { security: {
// IP-based access control // IP-based access control
ipAllowList: ['10.0.0.0/8', '192.168.*'], ipAllowList: ['10.0.0.0/8', '192.168.*'],
ipBlockList: ['192.168.1.100'], ipBlockList: ['192.168.1.100'],
// Connection limits // Connection limits
maxConnections: 1000, maxConnections: 1000,
maxConnectionsPerIp: 10, maxConnectionsPerIp: 10,
// Rate limiting // Rate limiting
rateLimit: { rateLimit: {
maxRequests: 100, maxRequests: 100,
windowMs: 60000 windowMs: 60000
},
// Authentication
authentication: {
type: 'jwt',
secret: process.env.JWT_SECRET,
algorithms: ['HS256']
} }
} }
} }
@@ -282,7 +310,7 @@ Comprehensive security options per route:
Control your proxy without restarts: Control your proxy without restarts:
```typescript ```typescript
// Add/remove ports dynamically // Dynamic port management
await proxy.addListeningPort(8443); await proxy.addListeningPort(8443);
await proxy.removeListeningPort(8080); await proxy.removeListeningPort(8080);
@@ -291,25 +319,31 @@ await proxy.updateRoutes([...newRoutes]);
// Monitor status // Monitor status
const status = proxy.getStatus(); const status = proxy.getStatus();
console.log(`Active connections: ${status.activeConnections}`);
// Get detailed metrics
const metrics = proxy.getMetrics(); const metrics = proxy.getMetrics();
console.log(`Throughput: ${metrics.throughput.bytesPerSecond} bytes/sec`);
// Certificate management // Certificate management
await proxy.renewCertificate('example.com');
const certInfo = proxy.getCertificateInfo('example.com'); const certInfo = proxy.getCertificateInfo('example.com');
console.log(`Certificate expires: ${certInfo.expiresAt}`);
``` ```
### 🔄 Header Manipulation ### 🔄 Header Manipulation
Transform requests and responses: Transform requests and responses with template variables:
```typescript ```typescript
{ {
action: { action: {
type: 'forward',
targets: [{ host: 'backend', port: 8080 }],
headers: { headers: {
request: { request: {
'X-Real-IP': '{clientIp}', // Template variables 'X-Real-IP': '{clientIp}',
'X-Request-ID': '{uuid}', 'X-Request-ID': '{uuid}',
'X-Custom': 'value' 'X-Forwarded-Proto': 'https'
}, },
response: { response: {
'X-Powered-By': 'SmartProxy', 'X-Powered-By': 'SmartProxy',
@@ -327,13 +361,15 @@ SmartProxy is built with a modular, extensible architecture:
``` ```
SmartProxy SmartProxy
├── 📋 Route Manager # Route matching and prioritization ├── 📋 RouteManager # Route matching and prioritization
├── 🔌 Port Manager # Dynamic port lifecycle ├── 🔌 PortManager # Dynamic port lifecycle management
├── 🔒 Certificate Manager # ACME/Let's Encrypt automation ├── 🔒 SmartCertManager # ACME/Let's Encrypt automation
├── 🚦 Connection Manager # Connection pooling and limits ├── 🚦 ConnectionManager # Connection pooling and tracking
├── 📊 Metrics Collector # Performance monitoring ├── 📊 MetricsCollector # Real-time performance monitoring
├── 🛡️ Security Manager # Access control and rate limiting ├── 🛡️ SecurityManager # Access control and rate limiting
└── 🔧 Protocol Detectors # Smart protocol identification ├── 🔧 ProtocolDetector # Smart HTTP/TLS/WebSocket detection
├── ⚡ NFTablesManager # Kernel-level forwarding (Linux)
└── 🌐 HttpProxyBridge # HTTP/HTTPS request handling
``` ```
## 🎯 Route Configuration Reference ## 🎯 Route Configuration Reference
@@ -346,87 +382,115 @@ interface IRouteMatch {
domains?: string | string[]; // 'example.com', '*.example.com' domains?: string | string[]; // 'example.com', '*.example.com'
path?: string; // '/api/*', '/users/:id' path?: string; // '/api/*', '/users/:id'
clientIp?: string | string[]; // '10.0.0.0/8', ['192.168.*'] clientIp?: string | string[]; // '10.0.0.0/8', ['192.168.*']
protocol?: 'tcp' | 'udp' | 'http' | 'https' | 'ws' | 'wss';
tlsVersion?: string | string[]; // ['TLSv1.2', 'TLSv1.3'] tlsVersion?: string | string[]; // ['TLSv1.2', 'TLSv1.3']
customMatcher?: (context) => boolean; // Custom logic
} }
``` ```
### Action Types ### Action Types
| Type | Description |
|------|-------------|
| `forward` | Proxy to one or more backend targets |
| `redirect` | HTTP redirect with status code |
| `block` | Block the connection |
| `socket-handler` | Custom socket handling function |
### TLS Options
```typescript ```typescript
interface IRouteAction { interface IRouteTls {
type: 'forward' | 'redirect' | 'block' | 'socket-handler'; mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
certificate: 'auto' | { key: string; cert: string };
// For 'forward' // For terminate-and-reencrypt:
targets?: Array<{ reencrypt?: {
host: string | string[] | ((context) => string); host: string;
port: number | ((context) => number); port: number;
}>; ca?: string; // Custom CA for backend
// For 'redirect'
redirectUrl?: string; // With {domain}, {path}, {clientIp} templates
redirectCode?: number; // 301, 302, etc.
// For 'socket-handler'
socketHandler?: (socket, context) => void | Promise<void>;
// TLS options
tls?: {
mode: 'terminate' | 'passthrough' | 'terminate-and-reencrypt';
certificate: 'auto' | { key: string; cert: string };
};
// WebSocket options
websocket?: {
enabled: boolean;
pingInterval?: number;
pingTimeout?: number;
}; };
} }
``` ```
## 🛠️ Helper Functions Reference
All helpers are fully typed and documented:
```typescript
import {
// HTTP/HTTPS
createHttpRoute,
createHttpsTerminateRoute,
createHttpsPassthroughRoute,
createHttpToHttpsRedirect,
createCompleteHttpsServer,
// Load Balancing
createLoadBalancerRoute,
createSmartLoadBalancer,
// API & WebSocket
createApiRoute,
createApiGatewayRoute,
createWebSocketRoute,
// Custom Protocols
createSocketHandlerRoute,
SocketHandlers,
// NFTables (Linux)
createNfTablesRoute,
createNfTablesTerminateRoute,
createCompleteNfTablesHttpsServer,
// Dynamic Routing
createPortMappingRoute,
createOffsetPortMappingRoute,
createDynamicRoute,
// Security Modifiers
addRateLimiting,
addBasicAuth,
addJwtAuth
} from '@push.rocks/smartproxy';
```
## 🐛 Troubleshooting ## 🐛 Troubleshooting
### Certificate Issues ### Certificate Issues
- ✅ Ensure domain points to your server - ✅ Ensure domain DNS points to your server
- ✅ Port 80 must be accessible for ACME challenges - ✅ Port 80 must be accessible for ACME HTTP-01 challenges
- ✅ Check DNS propagation with `nslookup` - ✅ Check DNS propagation with `dig` or `nslookup`
- ✅ Verify email in ACME configuration - ✅ Verify the email in ACME configuration is valid
### Connection Problems ### Connection Problems
- ✅ Check route priorities (higher = matched first) - ✅ Check route priorities (higher number = matched first)
- ✅ Verify security rules aren't blocking - ✅ Verify security rules aren't blocking legitimate traffic
- ✅ Test with `curl -v` for detailed output - ✅ Test with `curl -v` for detailed connection output
- ✅ Enable debug mode for verbose logging - ✅ Enable debug logging for verbose output
### Performance Tuning ### Performance Tuning
- ✅ Use NFTables for high-traffic routes - ✅ Use NFTables forwarding for high-traffic routes (Linux only)
- ✅ Enable connection pooling - ✅ Enable connection keep-alive where appropriate
- ✅ Adjust keep-alive settings - ✅ Monitor metrics to identify bottlenecks
- ✅ Monitor with built-in metrics - ✅ Adjust `maxConnections` based on your server resources
### Debug Mode ### Debug Mode
```typescript ```typescript
const proxy = new SmartProxy({ const proxy = new SmartProxy({
debug: true, // Enable verbose logging enableDetailedLogging: true, // Verbose connection logging
routes: [...] routes: [...]
}); });
``` ```
## 🚀 Migration from v20.x to v21.x
No breaking changes! v21.x adds enhanced socket cleanup, improved connection tracking, and better process exit handling.
## 🏆 Best Practices ## 🏆 Best Practices
1. **📝 Use Helper Functions** - They provide sensible defaults and prevent errors 1. **📝 Use Helper Functions** - They provide sensible defaults and prevent common mistakes
2. **🎯 Set Route Priorities** - More specific routes should have higher priority 2. **🎯 Set Route Priorities** - More specific routes should have higher priority values
3. **🔒 Always Enable Security** - Use IP filtering and rate limiting for public services 3. **🔒 Enable Security** - Always use IP filtering and rate limiting for public services
4. **📊 Monitor Performance** - Use metrics to identify bottlenecks 4. **📊 Monitor Metrics** - Use the built-in metrics to identify issues early
5. **🔄 Regular Certificate Checks** - Monitor expiration and renewal status 5. **🔄 Certificate Monitoring** - Set up alerts for certificate expiration
6. **🛑 Graceful Shutdown** - Always call `proxy.stop()` for clean shutdown 6. **🛑 Graceful Shutdown** - Always call `proxy.stop()` for clean connection termination
7. **🎮 Test Your Routes** - Use the route testing utilities before production 7. **🔧 Test Routes** - Validate your route configurations before deploying to production
## 📖 API Documentation ## 📖 API Documentation
@@ -434,74 +498,73 @@ No breaking changes! v21.x adds enhanced socket cleanup, improved connection tra
```typescript ```typescript
class SmartProxy { class SmartProxy {
constructor(options: IRoutedSmartProxyOptions); constructor(options: ISmartProxyOptions);
// Lifecycle // Lifecycle
start(): Promise<void>; start(): Promise<void>;
stop(): Promise<void>; stop(): Promise<void>;
// Route Management // Route Management
updateRoutes(routes: IRouteConfig[]): Promise<void>; updateRoutes(routes: IRouteConfig[]): Promise<void>;
addRoute(route: IRouteConfig): Promise<void>;
removeRoute(routeName: string): Promise<void>;
findMatchingRoute(context: Partial<IRouteContext>): IRouteConfig | null;
// Port Management // Port Management
addListeningPort(port: number): Promise<void>; addListeningPort(port: number): Promise<void>;
removeListeningPort(port: number): Promise<void>; removeListeningPort(port: number): Promise<void>;
getListeningPorts(): number[]; getListeningPorts(): number[];
// Certificate Management
getCertificateInfo(domain: string): ICertificateInfo | null;
renewCertificate(domain: string): Promise<void>;
// Monitoring // Monitoring
getStatus(): IProxyStatus; getStatus(): IProxyStatus;
getMetrics(): IProxyMetrics; getMetrics(): IMetrics;
// Certificate Management
getCertificateInfo(domain: string): ICertStatus | null;
} }
``` ```
### Helper Functions ### Configuration Options
All helper functions are fully typed and documented. Import them from the main package:
```typescript ```typescript
import { interface ISmartProxyOptions {
createHttpRoute, routes: IRouteConfig[]; // Required: array of route configs
createHttpsTerminateRoute,
createHttpsPassthroughRoute, // ACME/Let's Encrypt
createHttpToHttpsRedirect, acme?: {
createCompleteHttpsServer, email: string; // Contact email
createLoadBalancerRoute, useProduction?: boolean; // Use production servers (default: false)
createApiRoute, port?: number; // Challenge port (default: 80)
createWebSocketRoute, renewThresholdDays?: number; // Days before expiry to renew (default: 30)
createSocketHandlerRoute, };
createNfTablesRoute,
createPortMappingRoute, // Defaults
createDynamicRoute, defaults?: {
createApiGatewayRoute, target?: { host: string; port: number };
addRateLimiting, security?: IRouteSecurity;
addBasicAuth, tls?: IRouteTls;
addJwtAuth, };
SocketHandlers
} from '@push.rocks/smartproxy'; // Behavior
enableDetailedLogging?: boolean;
gracefulShutdownTimeout?: number; // ms to wait for connections to close
}
``` ```
## License and Legal Information ## License and Legal Information
This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.
**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file. **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
### Trademarks ### Trademarks
This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH. This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
### Company Information ### Company Information
Task Venture Capital GmbH Task Venture Capital GmbH
Registered at District court Bremen HRB 35230 HB, Germany Registered at District Court Bremen HRB 35230 HB, Germany
For any legal inquiries or if you require further information, please contact us via email at hello@task.vc. For any legal inquiries or further information, please contact us via email at hello@task.vc.
By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works. By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

2
ts/00_commitinfo_data.ts
View File

@@ -3,6 +3,6 @@
*/ */
export const commitinfo = { export const commitinfo = {
name: '@push.rocks/smartproxy', name: '@push.rocks/smartproxy',
version: '22.2.0', version: '22.3.0',
description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.' description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
} }