Hono is a TypeScript web framework built directly on Web Standards (Request, Response, Fetch, Web Crypto, ReadableStream), designed for serverless and edge runtimes. In production it accepts HTTP requests, matches them against routes via one of five router implementations, runs composed middleware chains, and produces standard Responses — with optional JSX server rendering, streaming (SSE, Suspense), input validation, static site generation, and a type-safe RPC client. It ships as a library whose main entry points are `src/index.ts` (exports the `Hono` class) and `src/hono.ts` (the default SmartRouter-backed instance), plus per-runtime adapter packages for Cloudflare Workers/Pages, Deno, Bun, AWS Lambda (API Gateway v1/v2, ALB, VPC Lattice), Node.js, Vercel, Netlify, Lambda@Edge, and Service Workers. Architecturally it is a modular monorepo: a small core (`src/hono-base.ts`, `src/context.ts`, `src/request.ts`, `src/compose.ts`), a router layer with genuinely novel implementations (RegExpRouter compiles a trie of registered routes into one optimized regex per HTTP method at runtime; SmartRouter dynamically selects the fastest router; plus TrieRouter, LinearRouter, PatternRouter), dozens of built-in middleware (CORS, CSRF, JWT/JWKS, secure-headers, ETag, cache, rate-limit-style helpers), helper modules (streaming/SSE, cookies, CSS-in-JS, WebSocket, testing), a custom JSX engine with both server-side streaming and a client-side DOM renderer, and a typed RPC client (`hc`) that derives request/response types from route schemas. The framework's signature is its deep type-level inference: handler chains, middleware variables, validation targets, and client calls are all statically checked. Code quality is exceptional. The RegExpRouter is a masterclass in performance engineering, the JWT utilities are self-contained Web Crypto implementations, and the entire codebase carries heavy test coverage (unit, conformance suites shared across routers, type-level tests, and runtime tests for every platform). It is actively maintained, continuously benchmarked against Express/Fastify-class routers, and tracks bundle size and type-check performance in CI. The main risk is complexity drift: `src/types.ts` contains dozens of generic overloads, the experimental JSX/DOM layer and SSG are marked unstable, and the in-repo runtime adapters are deprecated in favor of external `@hono/*` packages ahead of v5 — intentional migration, not neglect.
LLRT is a low-latency JavaScript runtime built in Rust around the QuickJS engine, designed primarily for AWS Lambda serverless workloads. The actual code confirms it is both a CLI runtime and a Lambda custom runtime: the `llrt` binary enters Lambda mode when `AWS_LAMBDA_RUNTIME_API` is present, and `runtime_client.rs` implements the full invoke/handler/response loop. It also provides `llrt compile` to emit QuickJS bytecode and self-contained executables, and `llrt test` to run a built-in Jest-compatible test runner. The runtime reimplements a broad surface of Node.js and Web APIs in Rust: `fs`, `net`, `http`, `crypto`/WebCrypto, `fetch`, `stream`/Web Streams, `events`, `timers`, `buffer`, `url`, `os`, `path`, `temporal`, `zlib`, `child_process`, `dgram`, and `intl`.
The Serverless Framework is a mature, open-source CLI tool for deploying and managing serverless applications on AWS. It compiles declarative YAML/JSON configuration (serverless.yml) into CloudFormation templates, orchestrates deployments via S3 artifact uploads and stack operations, and supports a wide range of AWS event sources (API Gateway, SQS, SNS, DynamoDB Streams, etc.). The repository is a monorepo with multiple packages: `sf-core` (new unified runner), `serverless` (legacy framework with AWS plugins), `engine` (AWS SDK client abstractions), `mcp` (Model Context Protocol server for AI agent integration), and `util` (shared logging, error handling, proxy support). Key entry points include `packages/sf-core/bin/sf-core.js` and `packages/serverless/lib/plugins/index.js`. The architecture is plugin-based, with lifecycle hooks for packaging, compiling events, and deploying. External dependencies include AWS SDK v2/v3, esbuild, and various npm packages. The codebase demonstrates high craftsmanship in areas like deterministic naming, proxy wrapping, and variable resolution, though some technical drift exists (dual SDK versions, deprecated providers).
Updo is a production-grade CLI tool for multi-target website uptime and performance monitoring. It continuously checks HTTP endpoints from the command line or a TOML configuration file, displaying real-time results in an interactive TUI or simple text output. The core monitoring engine performs configurable HTTP requests (GET/POST/PUT, custom headers, assertion text, redirect handling, SSL verification) and captures detailed timing breakdowns (DNS, TCP, TTFB, download). It can also deploy and invoke AWS Lambda functions across 13 global regions for geographically distributed probing, aggregating results from multiple vantage points. The tool integrates with Prometheus via Remote Write for long-term metric storage and visualization, and supports desktop alerts via beeep plus webhook notifications to Slack, Discord, or custom endpoints with auto-detected formatting. Architecture is a monolith Go application built on cobra for CLI management, termui for the TUI, and AWS SDK v2 for Lambda operations. Key entry points are the `updo monitor` and `updo aws` subcommands. Data flows from config or CLI flags through a monitoring loop that calls the HTTP checker or Lambda invoker, accumulates stats (t-digest for percentiles, rolling uptime), and pushes structured logs or Prometheus time series.
This repository is a Serverless Framework plugin that enables deploying Python WSGI applications (Flask, Django, Pyramid, etc.) to AWS Lambda via API Gateway or ALB. It automatically converts API Gateway events (v1, v2) and ALB requests into WSGI environ dictionaries, invokes the application, and transforms the response back into the appropriate Lambda proxy format. The plugin also provides a local development server (`sls wsgi serve`), automated dependency packaging from `requirements.txt`, and remote execution commands for Python code, shell commands, Django management commands, and Flask CLI commands. The codebase is split into a Node.js plugin (`index.js`) that hooks into Serverless lifecycle events (packaging, deployment, invoke local) and a set of Python modules (`serverless_wsgi.py`, `wsgi_handler.py`, `serve.py`, `requirements.py`) that handle the actual WSGI conversion, local serving, and dependency installation. The core WSGI adapter (`serverless_wsgi.py`) is a standalone, reusable library that can be used independently of the Serverless framework for any Lambda function needing to handle API Gateway events. The plugin is well-tested with both JavaScript and Python test suites, and follows a clean, modular architecture.
This Terraform module provisions an AWS SNS topic and a Lambda function (Python 3.13) that forwards SNS notifications to a Slack channel via webhook. The Lambda function parses and formats various AWS event types—CloudWatch alarms, GuardDuty findings, Security Hub findings, AWS Health events, AWS Backup notifications, and generic messages—into structured Slack attachments. It supports encrypted webhook URLs via KMS, custom Lambda functions, VPC configuration, and SNS subscription filtering. The module is part of the terraform-aws-modules ecosystem and follows standard Terraform module conventions with comprehensive CI/CD, pre-commit hooks, and semantic release. The Python code includes unit tests with snapshot testing, linting, and type checking, demonstrating solid engineering practices.
Tachyon is a production-grade serverless image resizing service built on AWS Lambda and S3. It takes HTTP requests that specify a path to an S3 object and query parameters (width, height, crop, quality, format, etc.), fetches the original image from S3 using the AWS SDK v3, resizes/transcodes it in-memory using the Sharp library (with support for animated GIF/WebP/PNG and smart cropping via smartcrop-sharp), and streams the result back to the client with appropriate cache headers. It natively supports presigned S3 URLs for accessing private objects by implementing a custom request signer that re-attaches presigned query parameters to the S3 GetObject call—bypassing the default SDK signing. The function is designed to be deployed as a single Lambda behind a Function URL (response streaming) or API Gateway, and includes a local development server for testing. While its primary use case is WordPress media handling (as part of the Human Made ecosystem), the core resizing and S3-fetching logic is framework-agnostic and could be adapted to any serverless image processing pipeline.
This repository contains a collection of AWS Lambda extension examples and demonstrations across multiple programming languages (Go, Python, Node.js, Java, C#, Rust) and wrapper scripts (Bash, Python, Ruby). Each example illustrates how to build a Lambda extension that integrates deeply with the Lambda execution environment using the Extensions API for lifecycle event registration, and the Logs API/Telemetry API for observability data processing. The extensions perform tasks such as forwarding logs to external destinations (S3, Kinesis, Firehose, Elasticsearch, etc.), collecting and sending telemetry data, implementing custom runtime behavior via wrapper scripts, and caching data from AWS services like DynamoDB and Parameter Store. The repository serves as a practical guide for developers to understand and implement Lambda extensions for observability, security, and governance use cases.
This repository implements a serverless document chat application that allows users to upload PDF documents and ask natural language questions. The backend is composed of AWS Lambda functions orchestrated by Amazon API Gateway, S3, SQS, and DynamoDB. PDF processing uses LangChain with FAISS for vector embeddings and Amazon Bedrock (Claude Sonnet) for LLM inference. The frontend is a React SPA with TypeScript, TailwindCSS, and AWS Amplify authentication. Architecture follows an event-driven serverless pattern: upload triggers S3 event → Lambda extracts PDF metadata, stores in DynamoDB, sends SQS message → another Lambda generates embeddings and stores FAISS index in S3. Chat requests invoke a Lambda that loads the FAISS index, retrieves relevant context, and uses a ConversationalRetrievalChain with DynamoDB-backed memory. The code is clean and follows AWS best practices with Powertools logging, but lacks tests and hardcodes the Bedrock region to us-east-1. It is a solid reference implementation for building a RAG-based Q&A system on AWS.
The Uniswap Routing API is a serverless AWS Lambda service that provides swap quotes across Uniswap V2, V3, V4, and mixed protocols on 20+ EVM chains. It is deployed via AWS CDK with API Gateway, DynamoDB for route/pool caching, S3 for token lists and pool snapshots, and CloudWatch for monitoring. The core quote handler (`lib/handlers/quote/quote.ts`) validates inputs, selects protocols, and delegates to the `@uniswap/smart-order-router` engine. A sophisticated RPC provider layer (`UniJsonRpcProvider`, `SingleJsonRpcProvider`) manages multi-provider failover, health checks, and latency-based selection. Traffic switching experiments (`TrafficSwitcher`) enable gradual rollouts of new implementations with shadow sampling. The system also includes cron-based pool caching, GraphQL-based token fee fetching, and extensive CloudWatch dashboards. While primarily an application, it incorporates data pipeline elements for caching and token list management. The codebase shows signs of deprecation (DECOMMISSION_FAILURE_RATE = 1 in the quote handler) and contains several hardcoded configurations and temporary workarounds, but overall demonstrates solid engineering with reusable abstractions.
This repository is a curated list of open-source AWS security tools, organized into categories such as defensive hardening, offensive testing, purple teaming, continuous auditing, DFIR, development security, S3 auditing, and training. It also includes a Packer-based build system to create an Amazon Machine Image (AMI) pre-loaded with many of the listed tools, alongside scripts for cloning tool repositories (install-tools.sh) and generating markdown tables from CSV data (arsenal-kreator.sh). The actual code in the repo is minimal—mainly configuration and simple shell scripts—and the core value is the comprehensive reference list. The AMI build is dated (last manifest from 2018) and many linked tools may have moved or become unmaintained, resulting in significant technical drift. The repo is more of a historic index than an actively developed software project.