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.
Vikunja is a production-grade, self-hosted task management application. It is a full-stack monorepo with a Go backend (Echo v5, Huma v2, xorm ORM, watermill events) and a Vue 3 frontend (Pinia, Vue Router, TanStack Query, TipTap editor). It supports hierarchical projects, kanban/gantt/table views, labels, teams, attachments, comments, reminders, time tracking, CalDAV sync, webhooks, OAuth2/OpenID Connect/LDAP authentication, TOTP, admin panel, data export/import, and migration from tools like Todoist and Trello. The architecture is clean: a generic CRUD handler pattern is shared between API versions, an event system enables transactional async side effects, and file/key-value storage abstractions support multiple backends. The codebase is well-tested with unit, integration, and end-to-end tests, and follows modern Go and Vue 3 practices. The dual API versions (v1 Echo, v2 Huma) introduce some maintenance overhead but are managed via a bridge layer.
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.
This is the official reference implementation of the AT Protocol (atproto) by Bluesky, implemented as a large TypeScript monorepo. It provides production-grade services for a decentralized social networking platform: a Personal Data Server (PDS) for user data storage, the Bluesky AppView (bsky) for social feed APIs, the Ozone moderation service, an OAuth 2.0 provider and client, and numerous supporting libraries for identity, cryptography, Lexicon schema validation, repository storage, and syncing. The architecture is microservice-oriented with internal gRPC communication (ConnectRPC) between the AppView and data plane, and relies on PostgreSQL, Redis, and AWS KMS for persistence and caching. The codebase is actively maintained with frequent commits, extensive test coverage, and a well-structured monorepo with many reusable packages.
FirebaseUI Web is a multi-package library that provides pre-built authentication UI components for web applications using Firebase Auth. It supports multiple frameworks (React, Angular, shadcn) with a shared core package that handles auth logic, state management, error handling, and internationalization. The library includes ready-to-use sign-in, sign-up, phone, email link, OAuth, and multi-factor authentication (SMS/TOTP) flows, all customizable via a composable behavior system. It is published as npm packages (@firebase-oss/ui-*) and includes extensive examples and end-to-end tests with Playwright against the Firebase Auth Emulator.
This repository provides `mmx-cli`, a TypeScript-based command-line interface for the MiniMax AI platform. It allows users to authenticate, generate text, images, video, speech, perform web search, and manage configuration entirely from the terminal. The codebase is modular with a command registry pattern, supports both OAuth and API key authentication, handles streaming responses (SSE), and includes a programmatic SDK for Node.js/TypeScript consumers. Key architectural patterns include a hierarchical command resolution system, a generic HTTP client with retry and timeout logic, file download utilities with atomic writes, and a polling utility for async task monitoring. The CLI also automates setup for third-party AI coding agents (Claude Code, Codex, Grok, etc.) by writing configuration files. Testing is extensive with a mock server pattern. The tool is dual-region (global and China) with automatic endpoint detection. While early in development (version 0.0.0-dev), the engineering quality is solid with clear separation of concerns, typed error handling, and thoughtful output formatting (text, JSON). Some components like the agent configurator and video generation validation are tightly coupled to MiniMax-specific APIs, but many utility and client modules exhibit patterns reusable in other CLI tools or API wrappers.
PhotoPrism is a self-hosted photo management server that indexes, organizes, and serves personal photo and video collections. In production, it extracts EXIF/XMP/IPTC metadata, generates thumbnails and previews, transcodes videos, performs AI-powered object/face recognition and NSFW detection, and provides a web UI for browsing, searching, sharing, and editing media. It also supports WebDAV access, OAuth2/OIDC authentication, and multi-instance clustering. The architecture is a monolithic Go application with a REST API (Gin framework) and a Vue.js frontend. It uses a relational database (MariaDB/MySQL or SQLite) via GORM. Background workers handle indexing, face recognition, place detection, and cleanup. It integrates with external tools: FFmpeg for video transcoding, libvips for image processing, TensorFlow/ONNX for AI models, and exiftool for metadata extraction. The frontend communicates via REST and WebSocket. Key entry points include the CLI (cmd/photoprism/photoprism.go) with subcommands for import, index, search, and user management, and the API layer (internal/api) exposing endpoints for photos, albums, labels, faces, places, and vision. The indexing pipeline scans configured directories, extracts metadata, generates thumbnails, runs AI models, and stores results in the database. The system also supports background sync with remote WebDAV services and backup/restore. External dependencies include FFmpeg, exiftool, libvips, TensorFlow, ONNX Runtime, Darktable, RawTherapee, yt-dlp, and various Go libraries. It can optionally integrate with OpenAI/Ollama for vision captioning. The codebase is large and mature, with extensive utility packages and a well-organized module structure.
mcp-agent is a Python framework for building, deploying, and serving AI agents that interact with the Model Context Protocol (MCP). In production, it provides a library and CLI toolkit that allows developers to compose agents using configurable LLM providers (OpenAI, Anthropic, Azure, Bedrock, Ollama, Google), connect to any MCP server (stdio, SSE, Websocket, Streamable HTTP), and orchestrate multi-step workflows with patterns like parallel fan-out/fan-in, router, orchestrator-worker, evaluator-optimizer, and swarm. The framework is architecture-agnostic, supporting both asyncio in-process execution and durable execution via Temporal for long-running, fault-tolerant agent loops. The system ships with a feature-rich CLI (mcp-agent) for local scaffolding, configuration, and cloud deployment to MCP Agent Cloud, including secret management, log tailing, and OAuth integration. Key entry points include the main application bootstrap (MCPApp), the Agent class (managing MCP server connections and LLM), workflow implementations in src/mcp_agent/workflows/, and the server module that exposes agents as MCP servers via FastMCP. The codebase is well-structured with clean abstractioons (ContextDependent, AugmentedLLM base), extensive testing (over 100 test files), and comprehensive observability through OpenTelemetry tracing, token counting, and structured logging. Use cases range from simple chat agents to complex research assistants, real estate analyts, and customer service desks with swarm routing. The framework is actively maintained with frequent commits, a large community, and is built to production standards.
Read the Docs is a Django-based web application for building, hosting, and serving documentation from version control repositories (GitHub, GitLab, Bitbucket). It supports Sphinx, MkDocs, and other documentation generators, with automated builds triggered by webhooks, versioning (semver, calver, custom), custom domains, subprojects, translations, and a full-text search powered by Elasticsearch. The platform includes a multi-tenant organization system with teams, invitations, and Stripe-based subscriptions for commercial features like concurrent builds and private documentation. Architecturally, it is a monolithic Django application with multiple apps (projects, builds, search, analytics, oauth, embed, proxito, etc.) communicating via Celery task queues for async operations (builds, indexing, email). It exposes REST APIs (v2 and v3) for programmatic access, and serves documentation through a custom proxito middleware that handles domain resolution, caching, redirects, and CDN integration. The codebase demonstrates strong engineering practices with extensive use of mixins, class overrides via SettingsOverrideObject, structured logging with structlog, and a comprehensive test suite. Key features include OAuth-based repository synchronization, automation rules for version management, an embed API for content fragments, file tree diff for pull request previews, audit logging, and spam detection. The system is designed for extensibility, with many components replaceable through Django settings, and relies on external services like AWS S3 for storage, Elasticsearch for search, and Stripe for payments.
Prismaliser is a fully client-side single-page application that visualizes Prisma database schemas as interactive entity-relationship diagrams. It runs entirely in the browser: the user pastes a Prisma schema into a Monaco editor, the app parses it client-side via a vendored WASM module from Prisma's own schema parser, and renders the models, enums, and relations (1-1, 1-n, m-n) as an interactive React Flow graph. The app has no backend server – it is a static Vite SPA that can be self-hosted (Docker image provided). Recently, AT Protocol (Bluesky) integration was added allowing users to publish immutable snapshots of their diagrams (schema + node positions) to their own AT repository, share via canonical AT links, and manage published snapshots. OAuth login is browser-native using the atcute library family. The codebase is TypeScript strict, thoroughly tested (Vitest), and follows modern React patterns with Tailwind CSS v4 and CSS modules. The architecture is modular: a util layer handles Prisma parsing, graph generation, and layout (elkjs), while a dedicated atproto/ module handles OAuth, record creation, public retrieval, and share link parsing. The UI is built with React 19, using local state and hooks (no global state management). The project is actively maintained with recent commits and open issue triage.
Tokimeki is a full-featured, open-source Bluesky client built with SvelteKit and TypeScript. It provides a multi-column deck layout (similar to TweetDeck) with support for multiple accounts, real-time timeline updates, chat (direct and group), rich media embeds, custom moderation (keyword mutes, labelers), and extensive customization (themes, keyboard shortcuts, layout options). The application uses the AT Protocol (XRPC) for all Bluesky interactions, implements OAuth and password-based authentication, and includes a service worker for push notifications and offline caching. Architecturally, Tokimeki is a single-page application (SPA) with server-side routes for OAuth flows, AI features (alt text generation, column icon suggestions), and proxy endpoints. State management is handled via Svelte 5 runes ($state, $derived) and custom reactive classes (ColumnState, AppState, PostState). Data persistence uses IndexedDB (via Dexie) for accounts, bookmarks, and drafts, and localStorage for settings. The codebase is modular with clear separation of concerns: UI components in src/lib/components/, state classes in src/lib/classes/, utilities in src/lib/, and routes in src/routes/. It includes a comprehensive test suite using Vitest and Playwright. Key features include a custom feed merge engine for combining multiple timelines, a virtual scrolling system with Fenwick tree for efficient rendering, an image compression pipeline with WebAssembly and fallback, a full chat system with group management, and an atmosphere service registry for third-party integrations. The application is internationalized with 10+ locales and supports on-device translation via the browser's Translator API.
This is a monorepo for 'pi', an AI coding assistant platform. The repository contains multiple packages including a coding agent with a terminal UI (TUI), multi-provider AI integration (OpenAI, Anthropic, Google, Bedrock, Mistral, xAI, and more), a durable execution framework for conversation persistence, a protocol layer with strict CBOR encoding, and telemetry infrastructure. The coding agent supports interactive mode with session management, tool orchestration, subagents, and MCP (Model Context Protocol) integration. The architecture is a TypeScript monorepo using npm workspaces with packages for AI providers, coding agent, durable execution, protocol, telemetry, and TUI components. The AI package provides a unified interface across multiple providers with OAuth flows, model catalogs, and streaming support. The coding agent implements a TUI with themes, keybindings, and interactive components. The durable package provides event-sourced storage with SQLite and JSONL backends, session management, and compaction. The repository also includes evaluation infrastructure (Docker-based evals), benchmarks for storage and delta traversal, and telemetry for usage tracking. The codebase demonstrates strong engineering practices with clean abstractions, reusable components, and comprehensive test coverage, though some areas (durable harness, experimental services) are still evolving.
Liberapay is a production web application for recurrent monetary donations, operating as a non-profit platform. It allows donors to set up weekly, monthly, or yearly contributions to creators, teams, and organizations. The architecture is a monolithic Python web application built on the custom Aspen/Pando framework (a fork of Aspen), using PostgreSQL for persistence, Jinja2 for server-side rendering, and a mix of Stripe and PayPal for payment processing. Key entry points include the homepage (`www/index.html.spt`), user profile pages (`www/%username/index.html.spt`), donation management (`www/%username/giving/`), payment flows (`www/%username/giving/pay/stripe/%payin_id.spt`), and admin dashboards (`www/admin/`). Data flows involve user authentication via sessions and OAuth, tip creation and scheduling, payin execution through Stripe/PayPal, weekly payday settlement, and email notifications. External dependencies include Stripe, PayPal, Amazon SES (email), Sentry (error tracking), S3 (file storage), and multiple OAuth providers (GitHub, Twitter, Mastodon, etc.). The codebase is well-structured with reusable modules for payment prospect calculation, encryption, content security policy, currency handling, and OAuth abstraction, though it carries technical debt from a custom framework and aging dependencies.
Kiro Account Manager is a Tauri-v2 desktop application (Rust + React/TypeScript) that manages multiple Kiro IDE accounts with smart switching, quota monitoring, token refresh, and machine-ID rotation to avoid multi-account association. It also ships a fully featured local HTTP gateway (Kiro2API) that exposes managed accounts via OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages APIs, with load balancing, model mapping, prompt filtering, response caching, and streaming. Additionally, the app provides a configuration surface for Kiro IDE settings, MCP servers, custom agents, skills, steering rules, hooks, and powers. It supports multiple authentication providers (Google, GitHub, AWS Builder ID, IAM Identity Center) and integrates with the Kiro CLI SQLite database for account import. The architecture follows a clean separation—Rust backend handles all business logic via Tauri IPC commands, while the React frontend uses Radix-based UI components and context-based state management. Despite its broad feature set, the codebase demonstrates professional engineering practices with extensive testing in both Rust and TypeScript, though some modules are monolithic and contain hardcoded constants tied to Kiro-specific APIs.
The httr package is an R library for making HTTP requests. It provides functions for the main HTTP verbs (GET, POST, PUT, DELETE, PATCH, HEAD) and a generic VERB function for custom verbs. It includes comprehensive support for HTTP configuration (authentication, headers, cookies, proxies, timeouts, etc.) and OAuth 1.0 and 2.0 authentication. Responses are captured in a response object and can be accessed as raw bytes, text, or parsed into common formats (JSON, XML, HTML, etc.). The package also includes utilities for URL parsing and building, media type parsing, HTTP date handling, retry logic with exponential backoff, and HTTP caching. Note: This package is superseded by httr2 for new development, but is still maintained for CRAN compatibility.
phpVMS is a full-stack virtual airline management platform built on Laravel. It provides a comprehensive admin panel (Filament) for managing aircraft, flights, pilots, PIREPs, awards, finances, and more, alongside a public-facing frontend (Vue 3 SPA with Inertia or legacy Blade theme) for pilots to file reports, bid on flights, and view live maps. The system integrates OAuth2 authentication (Passport), SimBrief flight planning, Discord notifications, and an addon/module system for extensibility. The architecture follows Laravel conventions with a service layer, DTOs, custom Eloquent casts, event-driven cron jobs, and a modern map rendering pipeline using maplibre-gl and three.js. While the codebase is well-structured and actively maintained, there is some technical drift from dual frontend frameworks (Blade vs Vue/Preact) and a large set of data migrations that complicate upgrades.
AIClient2API (A2) is a production-grade API proxy/gateway that converts proprietary AI provider APIs (Gemini, Claude/Kiro, Qwen, Codex, Grok, OpenAI, and more) into standard OpenAI-compatible endpoints (`/v1/chat/completions`, `/v1/messages`, `/v1beta/models`). It supports multi-account OAuth credential pools with automatic token refresh, health checks, and fallback routing, enabling clients to break free-tier restrictions. The server is built on Node.js with a master-worker architecture for process management, a plugin system for extensibility (authentication, monitoring, usage statistics, API key sharing), and a Go-based TLS sidecar for JA3/JA4 bypass. A full web management console (static HTML/CSS/JS) provides configuration, provider management, credential file upload, interactive playground, and usage monitoring. The codebase demonstrates strong patterns (strategy, factory, adapter, converter) but suffers from some monolithic utility files, hardcoded provider mappings, and high maintenance overhead from multiple OAuth implementations.
MultiMC is a mature, cross-platform desktop application written in C++/Qt that manages and launches multiple Minecraft instances. The code implements a complete launcher stack: instance creation/import/export and modpack management (Modrinth, Technic, ATLauncher, legacy FTB), Microsoft/Mojang account authentication via OAuth device flow, per-instance component profiles (Forge/Fabric/Quilt/NeoForge/LiteLoader), Java discovery/validation, asset/library download with an HTTP metacache and checksum validators, a composable launch pipeline, and a self-updater. The UI is organized around a Qt Widgets page/dialog system with global and per-instance settings pages and a custom instance grid view. The architecture is a conventional monolithic desktop application but is modularized internally into subsystems: tasks, network jobs, settings, metadata, auth, mod platforms, and UI pages. Main entry point is launcher/main.cpp, which boots Application and communicates through a centralized singleton; the command line supports --launch, --import, --server, --world, --offline, and single-instance peer forwarding. External dependencies include Qt 5, CMake, an extensive set of vendored libraries (katabasis for OAuth, classparser for Java class files, xz-embedded, hoedown, tomlc99, systeminfo), and remote services such as Mojang, Microsoft/Xbox Live, Modrinth, ATLauncher, Technic, Imgur, and paste.ee. The codebase is not a data pipeline; however it contains meaningful offline parsers (JSON, TOML, NBT, Java class files, INI) and test fixtures that are relevant to anyone working with Minecraft mod formats.
buji-pac4j is a bridge library that integrates pac4j (a comprehensive security library supporting OAuth, CAS, SAML, OpenID Connect, etc.) with Apache Shiro. It automatically pushes pac4j authentication and authorization profiles into the Shiro security context, allowing developers to use pac4j's wide range of authentication mechanisms while leveraging Shiro for authorization and session management. The bridge is implemented as a set of classes that adapt pac4j's session store, profile manager, and framework adapter to Shiro's APIs, plus a custom Realm, SubjectFactory, and Token. It includes sophisticated logic to avoid unnecessary session renewal when the same user's profiles are updated (e.g., after token refresh), demonstrating deep understanding of both frameworks' internals. The library is production-ready, actively maintained, and used in legacy applications that want to adopt pac4j without fully migrating away from Shiro.
python-o365 is a mature Python library that provides a comprehensive, object-oriented wrapper around the Microsoft Graph API. It enables developers to programmatically access and manage Microsoft 365 services including Outlook email and calendar, OneDrive and SharePoint files, Teams chats and presence, Planner tasks, directory users and groups, and more. The library abstracts OAuth2 authentication (supporting authorization code, public client, and client credentials flows) and handles token refresh, pagination, and API versioning internally. It is designed as a client-side SDK, not a server application, and can be embedded into scripts, web applications (e.g., Flask), or automation workflows.