git.zone/tspm
3
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

fix(crash-logging): migrate filesystem persistence to smartfs and stabilize crash log tests

Browse Source
This commit is contained in:
Jürgen Kunz
2026-03-24 19:00:14 +00:00
parent 0f794f76e8
commit 70c925a780
15 changed files with 2408 additions and 3611 deletions
Download Patch File Download Diff File Expand all files Collapse all files

618
readme.md
View File

@@ -1,347 +1,268 @@
# @git.zone/tspm 🚀
**TypeScript Process Manager** - A robust, no-fuss process manager designed specifically for TypeScript and Node.js applications. Built for developers who need reliable process management without the complexity.
**TypeScript Process Manager** — A robust, no-fuss process manager built for the modern TypeScript and Node.js ecosystem. Production-ready process management without the bloat.
## 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 TSPM?
TSPM (TypeScript Process Manager) is your production-ready process manager that handles the hard parts of running Node.js applications. It's like PM2, but built from the ground up for the modern TypeScript ecosystem with better memory management, intelligent logging, and a cleaner architecture.
TSPM is your production-ready process manager that handles the hard parts of running Node.js applications. Think PM2, but built from scratch for the TypeScript-first ecosystem with better memory management, intelligent logging, a clean daemon architecture, and native ESM support.
### ✨ Key Features
- **🧠 Smart Memory Management** - Tracks memory including child processes, enforces limits, and auto-restarts when exceeded
- **💾 Persistent Log Storage** - Keeps 10MB of logs in memory, persists to disk on restart/stop/error
- **🔄 Intelligent Auto-Restart** - Automatically restarts crashed processes with configurable policies
- **👀 File Watching** - Auto-restart on file changes for seamless development
- **🌳 Process Group Tracking** - Monitors parent and all child processes as a unit
- **🏗️ Daemon Architecture** - Survives terminal sessions with Unix socket IPC
- **📊 Beautiful CLI** - Clean, informative output with real-time status updates
- **📝 Structured Logging** - Captures stdout/stderr with timestamps and metadata
- **⚡ Zero Config** - Works out of the box, customize when needed
- **🔌 System Service** - Run as systemd service for production deployments
- 🧠 **Smart Memory Management** — Tracks memory across entire process trees (parent + children), enforces limits, and auto-restarts on OOM
- 💾 **Persistent Log Storage** — 10MB in-memory ring buffer per process, auto-persists to disk on stop/restart/crash
- 🔄 **Intelligent Auto-Restart** — Crashed processes restart with incremental backoff (1s → 10s), auto-stop after 10 consecutive failures
- 👀 **File Watching** — Auto-restart on file changes for seamless development workflows
- 🌳 **Process Tree Tracking** — Monitors parent and all child processes as a unit — no orphans, ever
- 🏗️ **Daemon Architecture** — Persistent background service that survives terminal sessions via Unix socket IPC
- 📊 **Beautiful CLI** — Clean, informative output with table views, real-time log streaming, and search
- ⚡ **Zero Config** — Works out of the box; customize only when you need to
- 🔌 **Systemd Integration** — Run as a system service for production deployments with `tspm enable`
- 🔍 **Crash Log Reports** — Detailed crash reports with metadata, memory snapshots, and log history
## 📦 Installation
```bash
# Install globally (recommended)
npm install -g @git.zone/tspm
# Or with pnpm
# Global install (recommended)
pnpm add -g @git.zone/tspm
# Or as a dev dependency
npm install --save-dev @git.zone/tspm
# Or with npm
npm install -g @git.zone/tspm
# Or as a project dependency
pnpm add --save-dev @git.zone/tspm
```
## 🚀 Quick Start
```bash
# Add a process (creates config without starting)
# Start the daemon
tspm daemon start
# Add a process
tspm add "node server.js" --name my-server --memory 1GB
# Start the process (by name or id)
# Start it
tspm start name:my-server
# or
tspm start id:1
# Or add and start in one go
tspm add "node app.js" --name my-app
tspm start name:my-app
# List all processes
# See what's running
tspm list
# View logs
tspm logs name:my-app
tspm logs name:my-server
# Stop a process
tspm stop name:my-app
# Stop it
tspm stop name:my-server
```
## 📋 Commands
## 📋 CLI Reference
### Targeting Processes
Most commands accept flexible process targeting:
| Format | Example | Description |
|--------|---------|-------------|
| Numeric ID | `tspm start 1` | Direct ID reference |
| `id:N` | `tspm start id:1` | Explicit ID prefix |
| `name:LABEL` | `tspm start name:api` | Target by name |
Use `tspm search <query>` to find processes by name or ID substring.
### Process Management
#### `tspm add <command> [options]`
Add a new process configuration without starting it. This is the recommended way to register processes.
Register a new process configuration (without starting it).
**Options:**
- `--name <name>` - Custom name for the process (required)
- `--memory <size>` - Memory limit (e.g., "512MB", "2GB", default: 512MB)
- `--cwd <path>` - Working directory (default: current directory)
- `--watch` - Enable file watching for auto-restart
- `--watch-paths <paths>` - Comma-separated paths to watch
- `--autorestart` - Auto-restart on crash (default: true)
- `-i, --interactive` - Enter interactive edit mode after adding
| Option | Description | Default |
|--------|-------------|---------|
| `--name <name>` | Process name | command string |
| `--memory <size>` | Memory limit (e.g. `512MB`, `2GB`) | `512MB` |
| `--cwd <path>` | Working directory | current directory |
| `--watch` | Enable file watching | `false` |
| `--watch-paths <paths>` | Comma-separated watch paths | — |
| `--autorestart` | Auto-restart on crash | `true` |
| `-i, --interactive` | Enter interactive edit after adding | — |
**Examples:**
```bash
# Add a simple Node.js app
# Simple Node.js app
tspm add "node server.js" --name api-server
# Add with 2GB memory limit
tspm add "node app.js" --name production-api --memory 2GB
# TypeScript with 2GB memory limit
tspm add "tsx src/index.ts" --name production-api --memory 2GB
# Add TypeScript app with watching
# Dev mode with file watching
tspm add "tsx watch src/index.ts" --name dev-server --watch --watch-paths "src,config"
# Add without auto-restart
tspm add "node worker.js" --name one-time-job --autorestart false
# One-shot worker (no auto-restart)
tspm add "node worker.js" --name batch-job --autorestart false
# Add and immediately edit interactively
# Add + interactive edit
tspm add "node server.js" --name api -i
```
#### `tspm start <id|id:N|name:LABEL>`
#### `tspm start <target>`
Start a previously added process by its ID or name.
Start a registered process.
```bash
tspm start name:my-server
tspm start id:1 # Or a bare numeric id: tspm start 1
tspm start id:1
tspm start 1 # bare numeric id also works
```
#### `tspm stop <id|id:N|name:LABEL>`
#### `tspm stop <target>`
Gracefully stop a running process (SIGTERM → SIGKILL after timeout).
Gracefully stop a process (SIGTERM → 5s grace → SIGKILL).
```bash
tspm stop name:my-server
```
#### `tspm restart <id|id:N|name:LABEL>`
#### `tspm restart <target>`
Stop and restart a process with the same configuration.
Stop and restart a process, preserving its configuration.
```bash
tspm restart name:my-server
```
#### `tspm delete <id|id:N|name:LABEL>` / `tspm remove <id|id:N|name:LABEL>`
#### `tspm delete <target>`
Stop and remove a process from TSPM management. Also deletes persisted logs.
Stop, remove from management, and delete persisted logs.
```bash
tspm delete name:old-server
tspm remove name:old-server # Alias for delete (daemon handles delete)
```
#### `tspm edit <id>`
#### `tspm edit <target>`
Interactively edit a process configuration.
Interactively modify a process configuration (name, command, memory, etc.).
```bash
tspm edit my-server
# Opens interactive prompts to modify name, command, memory, etc.
tspm edit name:my-server
```
### Monitoring & Information
#### `tspm search <query>`
Search processes by name or ID substring.
```bash
tspm search api
# Matches for "api":
# id:3 name:api-server
```
### Monitoring
#### `tspm list`
Display all managed processes in a beautiful table.
Display all managed processes in a table.
```bash
tspm list
# Output:
┌─────────┬─────────────┬───────────┬───────────┬──────────┬──────────┐
│ ID │ Name │ Status │ PID │ Memory │ Restarts │
├─────────┼─────────────┼───────────┼───────────┼──────────┼──────────┤
│ 1 │ my-app │ online │ 45123 │ 245.3 MB │ 0 │
│ 2 │ worker │ online │ 45456 │ 128.7 MB │ 2 │
│ 3 │ api-server │ stopped │ - │ 0 B │ 5 │
└─────────┴─────────────┴───────────┴───────────┴──────────┴──────────┘
```
┌─────┬─────────────┬──────────┬───────┬──────────┬──────────┐
│ ID │ Name │ Status │ PID │ Memory │ Restarts │
├─────┼─────────────┼──────────┼───────┼──────────┼──────────┤
│ 1 │ my-app │ online │ 45123 │ 245.3 MB │ 0 │
│ 2 │ worker │ online │ 45456 │ 128.7 MB │ 2 │
│ 3 │ api-server │ stopped │ - │ 0 B │ 5 │
└─────┴─────────────┴──────────┴───────┴──────────┴──────────┘
```
#### `tspm describe <id|id:N|name:LABEL>`
#### `tspm describe <target>`
Get detailed information about a specific process.
Detailed information about a specific process.
```bash
tspm describe name:my-server
# Output:
Process Details: my-server
────────────────────────────────────────
Status: online
PID: 45123
Memory: 245.3 MB
Uptime: 3600s
Restarts: 0
Configuration:
────────────────────────────────────────
Command: node server.js
Directory: /home/user/project
Memory Limit: 2 GB
Auto-restart: true
Watch: disabled
# Process Details: my-server
# ────────────────────────────────────────
# Status: online
# PID: 45123
# Memory: 245.3 MB
# Uptime: 3600s
# Restarts: 0
#
# Configuration:
# ────────────────────────────────────────
# Command: node server.js
# Directory: /home/user/project
# Memory Limit: 2 GB
# Auto-restart: true
# Watch: disabled
```
#### `tspm logs <id|id:N|name:LABEL> [options]`
#### `tspm logs <target> [options]`
View and stream process logs (stdout, stderr, and system messages).
View and stream process logs.
**Options:**
- `--lines <n>` Number of lines to show (default: 50)
- `--since <dur>` Only show logs since duration (e.g., `10m`, `2h`, `1d`; units: `ms|s|m|h|d`)
- `--stderr-only` Only show stderr logs
- `--stdout-only` Only show stdout logs
- `--ndjson` Output each log as JSON line (timestamp in ms)
- `--follow` Stream logs in real-time (like `tail -f`)
| Option | Description | Default |
|--------|-------------|---------|
| `--lines <n>` | Number of lines | `50` |
| `--since <dur>` | Time filter (`10m`, `2h`, `1d`) | — |
| `--stderr-only` | Only stderr | — |
| `--stdout-only` | Only stdout | — |
| `--ndjson` | Output as newline-delimited JSON | — |
| `--follow` | Real-time streaming (like `tail -f`) | — |
```bash
# View last 50 lines
tspm logs name:my-server
# View last 100 lines
tspm logs name:my-server --lines 100
# Last 100 lines of stderr only
tspm logs name:my-server --lines 100 --stderr-only
# Only stderr for the last 10 minutes (as NDJSON)
tspm logs name:my-server --since 10m --stderr-only --ndjson
# Follow logs in real time (prints recent lines, then streams backlog incrementally and live logs)
# Stream logs in real time
tspm logs name:my-server --follow
# Follow only stdout since 2h ago
tspm logs name:my-server --follow --since 2h --stdout-only
# NDJSON output since 10 minutes ago
tspm logs name:my-server --since 10m --ndjson
```
Notes:
- Follow mode prints a small recent backlog, then streams older entries incrementally (to avoid large payloads) and continues with live logs.
- Log sequences are restart-aware; TSPM detects run changes and keeps output consistent across restarts.
### Batch Operations
#### `tspm start-all`
Start all saved processes at once.
```bash
tspm start-all
# ✓ Started 3 processes:
# - my-app
# - worker
# - api-server
```
#### `tspm stop-all`
Stop all running processes.
```bash
tspm stop-all
# ✓ Stopped 3 processes
```
#### `tspm restart-all`
Restart all running processes.
```bash
tspm restart-all
# ✓ Restarted 3 processes
```
#### `tspm reset`
**⚠️ Dangerous:** Stop all processes and clear all configurations.
```bash
tspm reset
# Are you sure? (y/N)
# Stopped 3 processes.
# Cleared all configurations.
tspm start-all # Start all saved processes
tspm stop-all # Stop all running processes
tspm restart-all # Restart all running processes
tspm reset # ⚠️ Stop all + clear all configs (prompts for confirmation)
```
### Daemon Management
The TSPM daemon runs in the background and manages all your processes. It starts automatically when needed.
#### `tspm daemon start`
Manually start the TSPM daemon (usually automatic).
The daemon is a persistent background service that manages all processes. It starts automatically when needed.
```bash
tspm daemon start
# ✓ TSPM daemon started successfully
tspm daemon start # Start the daemon
tspm daemon stop # Stop daemon + all managed processes
tspm daemon restart # Restart daemon (preserves processes)
tspm daemon status # Check daemon health + stats
```
#### `tspm daemon stop`
Stop the daemon and all managed processes.
### System Service (systemd)
```bash
tspm daemon stop
# ✓ TSPM daemon stopped successfully
sudo tspm enable # Install + enable as systemd service (auto-start on boot)
sudo tspm disable # Remove systemd service
```
#### `tspm daemon restart`
Restart the daemon (preserves running processes).
```bash
tspm daemon restart
# ✓ TSPM daemon restarted successfully
```
#### `tspm daemon status`
Check daemon health and statistics.
```bash
tspm daemon status
# Output:
TSPM Daemon Status:
────────────────────────────────────────
Status: running
PID: 12345
Uptime: 86400s
Processes: 5
Socket: /home/user/.tspm/tspm.sock
```
#### Version check and service refresh
Check CLI vs daemon versions and refresh the systemd service if they differ:
### Version Check
```bash
tspm -v
# tspm CLI: 5.x.y
# Daemon: running v5.x.z (pid 1234)
# Version mismatch detected → optionally refresh the systemd service (equivalent to `tspm disable && tspm enable`).
```
This is helpful after upgrades where the system service still references an older CLI path.
### System Service Management
Run TSPM as a system service (systemd) for production deployments.
#### `tspm enable`
Enable TSPM as a system service that starts on boot.
```bash
sudo tspm enable
# ✓ TSPM daemon enabled and started as system service
# The daemon will now start automatically on system boot
```
#### `tspm disable`
Disable the TSPM system service.
```bash
sudo tspm disable
# ✓ TSPM daemon service disabled
# The daemon will no longer start on system boot
# Version mismatch detected → optionally refresh the systemd service
```
## 🏗️ Architecture
TSPM uses a robust three-tier architecture:
TSPM uses a clean three-tier architecture:
```
┌─────────────────────────────────────────┐
@@ -373,20 +294,29 @@ TSPM uses a robust three-tier architecture:
│ │ - Stream handling │ │
│ │ - Signal management │ │
│ └──────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────┐ │
│ │ CrashLogManager │ │
│ │ - Crash report generation │ │
│ │ - Log rotation (max 100) │ │
│ └──────────────────────────────────┘ │
└─────────────────────────────────────────┘
```
### Key Components
- **CLI** - Lightweight client that communicates with daemon via IPC
- **Daemon** - Persistent background service managing all processes
- **ProcessManager** - High-level orchestration and configuration
- **ProcessMonitor** - Adds monitoring, limits, and auto-restart
- **ProcessWrapper** - Low-level process lifecycle and streams
| Component | Role |
|-----------|------|
| **CLI** | Lightweight client that sends commands to daemon via IPC |
| **Daemon** | Persistent background service managing all processes |
| **ProcessManager** | High-level orchestration, config persistence, state management |
| **ProcessMonitor** | Memory limits, auto-restart with backoff, log persistence, file watching |
| **ProcessWrapper** | Low-level process lifecycle, stream handling, signal management |
| **CrashLogManager** | Detailed crash reports with metadata and log history |
## 🎮 Programmatic API
Use TSPM as a library in your Node.js applications:
TSPM exposes a typed IPC client for programmatic use:
```typescript
import { TspmIpcClient } from '@git.zone/tspm/client';
@@ -394,218 +324,152 @@ import { TspmIpcClient } from '@git.zone/tspm/client';
const client = new TspmIpcClient();
await client.connect();
// Add and start a process
// Add a process configuration
const { id } = await client.request('add', {
command: 'node worker.js',
name: 'background-worker',
projectDir: process.cwd(),
memoryLimit: 512 * 1024 * 1024, // 512MB in bytes
autorestart: true,
watch: false,
config: {
command: 'node worker.js',
name: 'background-worker',
projectDir: process.cwd(),
memoryLimitBytes: 512 * 1024 * 1024,
autorestart: true,
},
});
await client.request('start', { id });
// Start it
await client.request('startById', { id });
// Get process info
const { processInfo } = await client.request('describe', { id });
console.log(`Worker status: ${processInfo.status}`);
console.log(`Memory usage: ${processInfo.memory} bytes`);
console.log(`Status: ${processInfo.status}, Memory: ${processInfo.memory} bytes`);
// Get logs
const { logs } = await client.request('logs', { id, limit: 100 });
logs.forEach(log => {
console.log(`[${log.timestamp}] ${log.message}`);
});
const { logs } = await client.request('getLogs', { id, limit: 100 });
logs.forEach(log => console.log(`[${log.timestamp}] [${log.type}] ${log.message}`));
// Clean up
// Stop and remove
await client.request('stop', { id });
await client.request('delete', { id });
await client.disconnect();
```
### Module Exports
| Export Path | Purpose |
|-------------|---------|
| `@git.zone/tspm` | Main entry point (re-exports client + daemon) |
| `@git.zone/tspm/client` | IPC client (`TspmIpcClient`, `TspmServiceManager`) |
| `@git.zone/tspm/daemon` | Daemon entry point (`startDaemon`) |
| `@git.zone/tspm/protocol` | IPC type definitions |
## 🔧 Advanced Features
### Restart Backoff & Failure Handling
TSPM handles crashed processes with intelligent backoff:
- **Incremental delay**: Grows linearly from 1s up to 10s for consecutive restarts
- **Failure threshold**: After 10 consecutive failures, the process is marked `errored` and auto-restart stops
- **Auto-reset**: The retry counter resets if no failure occurs for 1 hour
- **Manual recovery**: `tspm restart id:1` always works, even on errored processes
### Memory Management
TSPM tracks total memory usage including all child processes:
- Uses `ps-tree` to discover child processes
- Calculates combined memory usage
- Gracefully restarts when limit exceeded
- Prevents memory leaks in production
Full process tree memory tracking:
- Discovers all child processes via `ps-tree`
- Calculates combined memory usage across the entire tree
- Gracefully restarts when limit is exceeded (SIGTERM → SIGKILL)
- Prevents memory leaks from taking down production systems
### Log Persistence
Intelligent log management system:
- Keeps 10MB of logs in memory per process
- Automatically flushes to disk on stop/restart/error
- Loads previous logs on process restart
- Cleans up persisted logs after loading
- Prevents disk space issues
Smart in-memory log management:
### Process Groups
Full process tree management:
- Tracks parent and all child processes
- Ensures complete cleanup on stop
- Accurate memory tracking across process trees
- No orphaned processes
- 10MB ring buffer per process with automatic trimming
- Flushes to disk on stop, restart, or crash
- Reloads persisted logs when process restarts
- Crash logs stored separately with full metadata (exit code, signal, memory, timestamps)
### Graceful Shutdown
Multi-stage shutdown process:
1. Send SIGTERM for graceful shutdown
2. Wait for process to clean up (5 seconds)
3. Send SIGKILL if still running
4. Clean up all child processes
Multi-stage shutdown for reliability:
1. Send **SIGTERM** for graceful shutdown
2. Wait **5 seconds** for process cleanup
3. Send **SIGKILL** if still alive
4. Clean up **all child processes** in the tree
### File Watching
Development-friendly auto-restart:
- Watch specific directories or files
- Ignore `node_modules` by default
- Debounced restart on changes
- Configurable watch paths
## 📊 Performance
TSPM is designed for production efficiency:
- **CPU Usage**: < 0.5% overhead per managed process
- **Memory**: ~30-50MB for daemon, ~5-10MB per managed process
- **Startup Time**: < 100ms to spawn new process
- **IPC Latency**: < 1ms for command execution
- **Log Performance**: Efficient ring buffer with automatic trimming
## 🛠️ Development
```bash
# Clone the repository
git clone https://code.foss.global/git.zone/tspm.git
cd tspm
# Install dependencies
pnpm install
# Run tests
pnpm test
# Build the project
pnpm build
# Run in development
pnpm start
```
### Project Structure
```
tspm/
├── ts/
│ ├── cli/ # CLI commands and interface
│ ├── client/ # IPC client for daemon communication
│ ├── daemon/ # Daemon server and process management
│ └── shared/ # Shared types and protocols
├── test/ # Test files
└── dist_ts/ # Compiled JavaScript
```
- `node_modules` ignored by default
- Debounced restart on file changes
- Configurable via `--watch-paths`
## 🐛 Debugging
Enable verbose logging for troubleshooting:
```bash
# Enable debug mode
export TSPM_DEBUG=true
tspm list
# Check daemon status
tspm daemon status
# Check daemon logs
# View process logs
tspm logs name:my-app --lines 200
# Check daemon stderr
tail -f /tmp/daemon-stderr.log
# Force daemon restart
tspm daemon restart
```
Common issues:
**Common issues:**
- **"Daemon not running"**: Run `tspm daemon start` or `tspm enable`
- **"Permission denied"**: Check socket permissions in `~/.tspm/`
- **"Process won't start"**: Check logs with `tspm logs <id|id:N|name:LABEL>`
| Problem | Solution |
|---------|----------|
| "Daemon not running" | `tspm daemon start` or `sudo tspm enable` |
| "Permission denied" | Check socket permissions in `~/.tspm/` |
| Process won't start | Check logs with `tspm logs <target>` |
| Memory limit exceeded | Increase with `tspm edit <target>` |
## 🎯 Targeting Processes (IDs and Names)
Most process commands accept the following target formats:
- Numeric ID: `tspm start 1`
- Explicit ID: `tspm start id:1`
- Explicit name: `tspm start name:api-server`
Notes:
- Names must be used with the `name:` prefix.
- If multiple processes share the same name, the CLI will report the ambiguous matches. Use `id:N` to disambiguate.
- Use `tspm search <query>` to discover IDs by name or ID fragments.
### `tspm search <query>`
Search processes by name or ID substring and print matching IDs (and names when available):
```bash
tspm search api
# Matches for "api":
# - id:3 name:api-server
```
- **"Memory limit exceeded"**: Increase limit with `tspm edit <id>`
## 🤝 Why Choose TSPM?
### TSPM vs PM2
## 🤝 Why TSPM?
| Feature | TSPM | PM2 |
|---------|------|-----|
| TypeScript Native | ✅ Built in TS | ❌ JavaScript |
| Memory Tracking | ✅ Including children | ⚠️ Main process only |
| Log Management | ✅ Smart 10MB buffer | ⚠️ Can grow unlimited |
| Architecture | ✅ Clean 3-tier | ❌ Monolithic |
| TypeScript Native | ✅ Built in TypeScript | ❌ JavaScript |
| Memory Tracking | ✅ Full process tree | ⚠️ Main process only |
| Log Management | ✅ Smart 10MB buffer | ⚠️ Can grow unbounded |
| Architecture | ✅ Clean 3-tier daemon | ❌ Monolithic |
| Dependencies | ✅ Minimal | ❌ Heavy |
| ESM Support | ✅ Native | ⚠️ Partial |
| Config Format | ✅ Simple JSON | ❌ Complex ecosystem |
| Crash Reports | ✅ Detailed with metadata | ❌ Basic |
### Perfect For
### Restart Backoff and Failure Handling
TSPM automatically restarts crashed processes with an incremental backoff:
- Debounce delay grows linearly from 1s up to 10s for consecutive retries.
- After the 10th retry, the process is marked as failed (status: "errored") and auto-restarts stop.
- The retry counter resets if no retry happens for 1 hour since the last attempt.
You can manually restart a failed process at any time:
```bash
tspm restart id:1
```
- 🚀 **Production Node.js apps** - Reliable process management
- 🔧 **Microservices** - Manage multiple services easily
- 👨‍💻 **Development** - File watching and auto-restart
- 🏭 **Worker processes** - Queue workers, cron jobs
- 📊 **Resource-constrained environments** - Memory limits prevent OOM
- 🚀 **Production Node.js apps** — Reliable process management with memory guards
- 🔧 **Microservices** — Manage multiple services from a single tool
- 👨‍💻 **Development** — File watching and instant auto-restart
- 🏭 **Workers & Jobs** — Queue workers, cron jobs, background tasks
- 📊 **Resource-constrained environments** — Memory limits prevent OOM kills
## 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.
### 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
Task Venture Capital GmbH
Registered at District court Bremen HRB 35230 HB, Germany
Task Venture Capital GmbH
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.