PM2 is a production process manager for Node.js applications with built-in load balancing, monitoring, and deployment capabilities. It keeps applications alive forever, enables zero-downtime reloads, and provides comprehensive system administration features. The architecture features a daemon-based design with CLI and programmatic APIs communicating via IPC (pm2-axon). Key capabilities include process clustering, log management, metrics collection, Docker integration, startup script generation, and a plugin system for extensibility. The codebase demonstrates strong engineering practices with internalized dependencies to reduce supply chain risk, comprehensive test coverage, and active maintenance with regular updates supporting Node.js >=18 and Bun.
Drizzle ORM is a headless, type-safe SQL query builder and ORM for TypeScript/JavaScript, supporting PostgreSQL, MySQL, SQLite, and serverless databases (Neon, PlanetScale, Cloudflare D1, Turso, etc.). The repository is a monorepo containing the core ORM library (`drizzle-orm`), a CLI tool (`drizzle-kit`) for schema introspection, migration generation, and database push/pull, a data seeding library (`drizzle-seed`), validation schema generators (`drizzle-zod`, `drizzle-valibot`, `drizzle-typebox`, `drizzle-arktype`), and an ESLint plugin (`eslint-plugin-drizzle`). The architecture follows a dialect abstraction pattern: each database has its own column builders, query builders (select, insert, update, delete), and session implementations that wrap native client libraries. The core provides composable SQL building via template literals, runtime type identification via the `entityKind` pattern, and a caching layer with tag-based invalidation. The CLI uses Zod-based configuration validation and generates migration SQL by diffing serialized schema snapshots. Integration tests run against real databases in Docker containers, and extensive type tests ensure compile-time correctness. External dependencies include various database client libraries (pg, mysql2, better-sqlite3, libsql, @neondatabase/serverless, etc.) and validation libraries (zod, valibot, typebox, arktype).
This is a monorepo for Auth.js (formerly NextAuth.js), a framework-agnostic authentication library for web applications. The core engine (`@auth/core`) handles OAuth/OIDC, email/passwordless, credentials, and WebAuthn/Passkey authentication flows. It provides a unified API for session management (JWT or database-backed), CSRF protection, and cookie handling. The library is designed to be integrated into multiple frameworks via separate packages: `@auth/nextjs`, `@auth/sveltekit`, `@auth/express`, `@auth/qwik`, and `@auth/solid-start`. Each framework package adapts the core `Auth` function to the framework's request/response model, offering server-side handlers, middleware, and client-side hooks. The repository also includes over 80 built-in OAuth/OIDC provider definitions (e.g., Google, GitHub, Discord, Auth0) and 20+ database adapters (e.g., Prisma, Drizzle, MongoDB, PostgreSQL, DynamoDB) that implement a standard `Adapter` interface for user persistence. The project is now part of Better Auth, and the README recommends new projects use Better Auth unless specific feature gaps exist. The monorepo contains development apps, example applications, and a comprehensive documentation site built with Nextra.
This repository is a comprehensive string validation and sanitization library for Node.js and browser environments. It provides a large collection of validator functions (e.g., isEmail, isURL, isMobilePhone, isCreditCard) and sanitizers (e.g., trim, escape, whitelist). The library is designed as a set of small, self-contained modules under src/lib/, each exporting a single function. The main entry point is src/index.js, which aggregates all validators and sanitizers into a single export. The library has no runtime dependencies and can be used both server-side and client-side (via a UMD bundle). It includes extensive locale-specific data for phone numbers, postal codes, tax IDs, etc., making it suitable for international validation. The architecture follows a consistent pattern: each validator imports assertString for type checking and optionally merge for options handling, then performs validation using regex or algorithmic checks. The library is actively maintained with frequent releases and a formal security threat model.
VoltAgent is a large TypeScript monorepo for building, deploying, observing, and evaluating AI agents. The core package provides an agent runtime with tool calling, memory, subagents, guardrails, workflow orchestration, MCP client integration, A2A protocol support, voice, and OpenTelemetry-based observability. Framework adapters expose this runtime as HTTP/SSE/WebSocket servers via Hono, Elysia, and serverless function providers, while a CLI scaffolds projects and manages VoltOps deployment/auth flows. The repo is fundamentally an application framework, though it contains hybrid data-oriented subsystems: a RAG package with many document chunking strategies, vector adapters, and BM25 search, plus evaluation/scoring packages used for LLM benchmark experiments.
Agenda is a light-weight job scheduling library for Node.js with a pluggable backend architecture. The core library provides scheduling (cron, human-readable intervals, debounce), concurrency control, distributed locking, retries with composable backoff strategies, unique job constraints, and persistent job logging. It supports three official backends (MongoDB, PostgreSQL, Redis) via clean abstractions (JobRepository, NotificationChannel, JobLogger) that can be mixed and matched. The monorepo also includes two companion applications: agendash (a Vue 3 web dashboard for monitoring and managing jobs with real-time SSE updates) and agenda-rest (a Koa-based REST API server with CLI entry point). The codebase is fully TypeScript, ESM-only (v6), uses pnpm workspaces, changesets for versioning, Vitest for testing, and has extensive shared test suites that ensure backend interoperability. The architecture demonstrates strong separation of concerns, but there is some code duplication across backends and legacy v4 documentation that could cause confusion.
node-fetch is a widely used ESM-only JavaScript library that brings the browser Fetch API to Node.js. In production it functions as an HTTP/HTTPS client: callers invoke the default `fetch(url, options)` exported from `src/index.js` and receive a `Response` backed by native Node.js Readable streams. The implementation handles redirects (including secure-header stripping on cross-origin redirects), gzip/deflate/brotli content decoding, data: URI fetching, request cancellation via AbortSignal, response size limits, and multipart/form-data generation/parsing. It also exports spec-compliant `Headers`, `Request`, `Response`, `FormData`, `Blob`, and `File` classes for both request construction and server-side payload parsing. Architecturally, the code is a modular library, not a service: `src/body.js` provides the shared Body mixin; `src/request.js` and `src/response.js` build on it; `src/headers.js` implements the Web IDL Headers interface; `src/index.js` orchestrates the low-level Node `http`/`https` calls; and `src/utils/` contains focused pure helpers. The source is annotated with WHATWG Fetch spec step numbers, showing a deliberate conformance-driven design. Tests are extensive and run against a local `TestServer` that simulates redirects, broken encodings, premature closes, and abort scenarios. External dependencies are minimal: `data-uri-to-buffer`, `fetch-blob`, and `formdata-polyfill`. The package declares Node `^12.20.0 || ^14.13.1 || >=16.0.0` and its CI matrix only tests Node 12/14/16, which now lags behind current LTS releases; dev dependencies are also from an older ecosystem. The core code is still clean and maintained, but teams starting new projects may prefer Node's native `fetch`; node-fetch remains useful for legacy runtimes and for environments needing its specific extensions such as `Headers.raw()` and custom agents.
Dillinger is a cloud-enabled, online Markdown editor with live preview, export to Markdown, HTML, and PDF, and synchronization with cloud storage services including GitHub, Dropbox, Google Drive, OneDrive, and Bitbucket. Built with Next.js 14 (App Router), the application uses Monaco Editor for editing, Zustand for client-side state management with localStorage persistence, and markdown-it with a rich plugin chain for rendering. It features a modular architecture with API routes for OAuth flows and file operations per cloud provider, a versioned public REST API (v1) for rendering and export, and separate packages for a CLI tool and an MCP server for LLM integration. The codebase is well-organized with clear component separation (editor, preview, sidebar, modals, UI primitives), custom hooks per integration, and comprehensive unit and E2E test coverage. Auxiliary agent/skill files and design system CSVs exist in the repository but are development tools, not part of the application runtime.
stripe-node is the official Stripe API client library for Node.js and JavaScript runtimes. It provides a comprehensive, typed interface to the entire Stripe REST API (both V1 and V2), covering payments, billing, Connect, Treasury, Issuing, Terminal, and more. The library is auto-generated from Stripe's OpenAPI spec, ensuring tight alignment with the API surface. It supports multiple JavaScript runtimes (Node.js, Deno, Cloudflare Workers, browsers) via platform abstraction layers for HTTP, crypto, and event emission. Key architectural features include a pluggable HTTP client hierarchy (Node native, Fetch, custom endpoints), runtime type coercion for V2 decimal and int64 fields, robust error generation with typed error classes, automatic pagination with async iterators, and webhook signature verification. The codebase is well-tested with unit and integration tests across runtimes, and follows semantic versioning. While the vast majority of resource files are generated boilerplate, the core infrastructure (request sender, platform functions, crypto providers, auto-pagination) demonstrates solid engineering craftsmanship and is designed for extensibility.
DeePMD-kit is a comprehensive, production-grade deep learning package for many-body interatomic potential energy representation and molecular dynamics simulation. It provides a unified framework for training and deploying machine learning interatomic potentials (MLIPs) across multiple backends: TensorFlow, PyTorch, JAX, and PaddlePaddle, with a backend-agnostic core (dpmodel) that ensures numerical consistency. The package supports a wide range of descriptor architectures (SeA, SeR, SeT, DPA1/2/3/4, attention-based, hybrid) and fitting targets (energy, force, virial, dipole, polarizability, density of states, spin, property). It integrates tightly with LAMMPS via custom pair styles and plugins, and also supports ASE, i-PI, GROMACS, and other MD engines. The codebase is highly modular, with a plugin registration system for models, descriptors, and losses, and offers extensive serialization capabilities for model export and compression. Pretrained models (DPA-3, DPA-4) are available for direct download and fine-tuning. The project is actively maintained with a large community, comprehensive test suites, and continuous integration across CPU and GPU platforms.
TSRPC is a TypeScript RPC framework designed for building type-safe, high-performance client-server applications. It provides both HTTP and WebSocket transports with optional JSON compatibility. The framework is built on a custom binary serialization algorithm (TSBuffer) that supports advanced TypeScript type features like union types, intersection types, and mapped types, eliminating the need for external IDL languages. TSRPC includes a rich middleware system called Flows, allowing interception and transformation of data at various stages of request/response processing. The core architecture is abstract and extensible: BaseServer, BaseConnection, and BaseCall form the foundation, with concrete implementations for HTTP (HttpServer, HttpConnection, ApiCallHttp) and WebSocket (WsServer, WsConnection, ApiCallWs). The client side mirrors this with HttpClient and WsClient that handle protocol encoding/decoding, timeouts, and automatic request aborting. The framework also supports server-to-client messages, broadcasting, heartbeat management, and graceful shutdown. With over 1900 GitHub stars and an active maintenance history (latest version 3.4.21), the codebase demonstrates solid engineering practices: comprehensive test coverage across multiple transport modes (HTTP, HTTPS, WS, WSS, both binary and JSON), clean separation of concerns, and robust error handling. The repository includes benchmarking tools and integration tests that verify correctness under various conditions.
Sidequest.js is a Redis-free background job processing system for Node.js/TypeScript that provides distributed, durable job processing using existing databases (PostgreSQL, MySQL, SQLite, MongoDB). The system features a modular monorepo architecture with separate packages for core logic, engine, database backends, web dashboard, and CLI tools. It implements job lifecycle management, scheduling via cron expressions, uniqueness constraints, retry mechanisms with backoff strategies, and provides a web interface for monitoring and management. The architecture follows clean separation of concerns with dependency injection, worker thread isolation via Piscina, and process isolation through forked child processes. Key entry points include the main Sidequest facade, engine configuration, dashboard interface, and CLI administration tools.
Jco is a JavaScript toolchain for WebAssembly components. It transpiles WASM components to JavaScript, generates TypeScript types from WIT, bundles components, and provides a standard library (`jco-std`) that ports Node.js built-in modules (fs, http, tls, net, crypto, zlib, etc.) to run inside WebAssembly components via WASI Preview 2/3. The monorepo contains a Rust workspace (bindgen crates, test components) and TypeScript packages (jco CLI, jco-transpile, preview2-shim, preview3-shim, jco-std). The codebase is notable for its differential testing approach: shims are tested against native Node.js behavior, with tests for HTTP/2, TLS, SQLite, streams, and worker threads. A dual-adapter pattern (deny-by-default vs. Node-native) ensures security by default. The project supports multiple WASI versions (0.2.x, 0.3.x) and Node.js versions (24.x, 26.x), with dedicated shims for browser and Node.js runtimes. Maintenance is active (recent commits, CI workflows), but there are drift risks: pinned Node.js versions, many TODO comments, incomplete browser shims (throwing Todo), and experimental features like JSPI and async support.
Offen Fair Web Analytics is a privacy-focused, self-hosted web analytics platform that emphasizes user consent and data ownership. The system employs a multi-service architecture consisting of a Go-based backend server for API and data persistence, a Node.js vault service for client-side encryption and key management, a Node.js tracking script for event collection, and a Node.js auditorium interface for users to view their analytics data. All services are orchestrated via Docker Compose, with Nginx acting as a reverse proxy. The platform ensures privacy through end-to-end encryption of analytics data in the browser before transmission to the server, preventing even the server operator from accessing raw data without the user's key. It implements granular consent management, data retention policies (default 6 months), and allows users to review, export, or delete their data via the auditorium. The system supports multiple databases (SQLite, MySQL, PostgreSQL) and provides internationalization for over six languages.
ADAMANT Forging Pool is a blockchain service that calculates and distributes delegate voter rewards on the ADAMANT network. It consists of a Node.js/Express backend that processes forged blocks, computes voter rewards, handles scheduled payouts, and maintains MongoDB storage for blocks, voters, and transactions. The system features a Svelte/Vite web dashboard for monitoring pool status and voter rewards, plus a control CLI (`adm-pool`) for managing encrypted passphrases. Key security features include operator-encrypted passphrases, input validation to prevent NoSQL injection, and secret-free health monitoring. The architecture follows a modular design with clear separation between API handling, business logic, data storage, and external integrations.
code-server is a production-grade application that runs Visual Studio Code on a remote server, making it accessible via any modern web browser. It is not a research or data pipeline project; it is a full-stack web application with a Node.js/Express backend, WebSocket support, and extensive CLI tooling. The system authenticates users via password (argon2 hashing) or custom auth, manages VS Code server processes as child processes, and provides proxying for local services (path-based and domain-based). It includes a Helm chart for Kubernetes deployment, Docker images for multiple Linux distributions, and an install script for various platforms. The architecture is a monolith with a parent/child process wrapper for graceful restarts and signal handling, and it relies on external dependencies such as VS Code itself (as a submodule with quilt patches), Express, ws, httpolyglot, and argon2. Key entry points include src/node/entry.ts (CLI parsing and server startup), src/node/main.ts (server creation), and src/node/app.ts (Express app and WebSocket router setup). The codebase is heavily patched (27+ .diff files) to adapt VS Code for remote use, adding features like base path support, custom marketplace, telemetry, logout, and iframe integration. While the patching approach is fragile and tightly coupled to VS Code's internal APIs, the core server infrastructure and many utility modules are well-architected and reusable.
Coolify is a self-hosted Platform-as-a-Service (PaaS) that enables users to deploy and manage applications, databases, and services on their own infrastructure. It serves as an open-source alternative to Heroku, Netlify, or Vercel, supporting Docker-based deployments with Git integration (GitHub, GitLab, Gitea, Bitbucket), multiple build packs (Railpack, Nixpacks), and one-click service templates. The system manages servers, reverse proxies (Traefik/Caddy), SSL certificates, scheduled backups, and multi-channel notifications (email, Discord, Slack, Telegram, Pushover, webhook). The architecture is a Laravel monolith with a Livewire + Alpine.js frontend for the v4 UI and a React + TypeScript canvas-based interface for the v5 UI. Background jobs are handled by Laravel Horizon with dedicated queues for deployments, cron tasks, and reconciliation. Real-time updates use Soketi (a Pusher-compatible WebSocket server) and Laravel Echo. The system integrates with cloud providers (Hetzner, Vultr, DigitalOcean) for server provisioning and Stripe for subscription billing. A Model Context Protocol (MCP) server exposes resources and tools for AI assistant integration. Key data flows include: webhook ingestion from Git providers triggering deployment jobs, SSH-based remote command execution on managed servers, Docker Compose parsing and environment variable injection, database backup scheduling with S3 storage, and proxy configuration generation. The v5 architecture introduces a control-plane/agent split with Flux (HTTP socket) and coold (gRPC) components for improved scalability and isolation. External dependencies include Docker, PostgreSQL, Redis, Soketi, Stripe API, cloud provider APIs, and various notification service endpoints. The codebase is actively developed with frequent schema migrations and a dual v4/v5 code path, indicating ongoing architectural evolution.
Joplin is a mature, cross-platform note-taking and synchronization application built on a monorepo architecture using Yarn Workspaces. It comprises four primary application layers: a desktop client (Electron/React), a mobile client (React Native), a CLI tool (Node.js), and a self-hosted server (Node.js/Koa). The core business logic resides in `packages/lib`, which handles data models (Notes, Folders, Tags), encryption (E2EE), and synchronization protocols (WebDAV, Joplin Server, Dropbox, etc.). The codebase demonstrates strong engineering practices with TypeScript, Redux state management, and a robust plugin system that allows third-party extensibility via a defined API. It supports multiple editor backends (CodeMirror, ProseMirror, TinyMCE) and integrates native modules for performance-critical tasks like OneNote parsing (Rust) and voice transcription (Whisper).
Novu is a comprehensive notification infrastructure platform designed for multi-channel delivery (Email, SMS, Push, Chat, In-App) and workflow orchestration. It functions as both a SaaS product and a self-hosted solution, providing a unified API to manage subscribers, triggers, and notification templates. The system integrates deeply with AI agents, supporting Model Context Protocol (MCP) and managed runtimes (e.g., Anthropic) for conversational notifications. The architecture is a TypeScript monorepo managed by Nx and pnpm, featuring a NestJS backend (API, Worker, WebSocket), React/Next.js frontend (Dashboard, Playground), and MongoDB/Redis/ClickHouse data stores. It emphasizes extensibility through a provider factory pattern and a programmatic workflow DSL.
This is a production-ready Node.js/Express web application boilerplate designed to jumpstart hackathon projects. The codebase implements a complete user authentication system supporting local email/password, OAuth 2.0/OAuth 1.0a (10+ providers including Google, Facebook, GitHub, Discord, Microsoft), WebAuthn passkeys, and two-factor authentication (TOTP + email). It includes session management with MongoDB, CSRF protection, rate limiting, and custom security measures like timing-safe token comparisons and IP-bound token consumption. Beyond auth, it ships working demos for ~20 third-party API integrations (Stripe, Twilio, GitHub, NYT, Wikipedia, etc.) and AI features powered by LangChain and Groq, including a ReAct agent with SSE streaming, a RAG pipeline with vector search, and LLM-based classification/vision. The repository also provides a sophisticated Playwright-based e2e testing framework using nock-recorded HTTP fixtures, enabling deterministic offline tests without live API keys. All features are organized as deletable modules with a removal checklist to facilitate trimming for production use.