CPANscan

Fugu is a collection of Perl modules that package the common plumbing used by OpenBSD-style daemons into reusable components. It gives you daemonization, configuration parsing, logging, PID and control sockets, privilege dropping, sandboxing, signal and child process handling, a simple event loop, IPC tools including an imsg codec and newline-delimited JSON over sockets, and utility pieces like an MQTT subscriber, HTTP proxy, REPL and file/state helpers. The distribution targets single-process server-style programs, requires only core Perl 5.36 with optional CPAN features loaded lazily, and includes a sans-IO Protocol::Imsg implementation. Pick Fugu when you need a ready-made, production-oriented toolkit for building and operating daemon-like Perl services.

Data::HashMap::Shared is a high-performance shared-memory hash map for Linux 64-bit Perl that makes it easy to share keyed data, counters and caches between processes by memory-mapping a file or using memfd/anonymous mappings. It provides several type-specialized variants for integer and string keys and values, optional LRU eviction and per-key TTLs so the same structure can act as a fast cross-process cache, lock-free read paths and futex-based writers for low overhead, atomic counters and CAS operations, sharding for parallel writes, and conveniences like batch ops, cursors, freeze/read-only snapshots and diagnostic stats. Small strings are stored inline and larger values use an arena allocator with explicit sizing, and the module exposes both fast keyword-style functions and normal method calls. It is designed for speed and real-world use but comes with practical cautions about crash-recovery, TTLs tied to the local monotonic clock and PID-based recovery across reboots or different PID namespaces. In the recent 0.20 release inserts now reclaim expired slots and will evict to satisfy arena allocation even on overwrite, and sharded sets now record shard count and route on a different part of the hash which is an incompatible change requiring all processes that share a sharded set to be upgraded together.

WWW::Mechanize::Chrome is a Perl module that controls a Chrome or Chromium browser via the Chrome DevTools Protocol, giving you a familiar WWW::Mechanize-style object to drive real browser tabs. It delegates fetching and rendering to Chrome so you can execute JavaScript, query the DOM with CSS selectors or XPath, intercept and inspect network requests, take screenshots or produce PDFs, and interact with forms and dialogs, making it well suited for scraping modern JavaScript-heavy sites, automated testing, and tasks that require a full browser engine. The module can run Chrome visibly or headless and returns HTTP::Response objects for compatibility, but it does require a Chrome-compatible browser to be installed and still lacks some WWW::Mechanize methods such as full POST support and a few legacy features, so check the docs for limits and quirks.

Loop provides compact, high-level iterators for Perl variables so you can process arrays, hashes, and files with minimal boilerplate. It supplies array iterators that pass the current index and allow in-place modification of the original array by assigning to the parameter, hash iterators that support safe nested looping over the same hash without conflicts, and file iterators that hand you line numbers and text for straightforward line-by-line processing. The interface is lightweight and non-exporting so you invoke Loop::Array, Loop::Hash or Loop::File with the target and a callback subroutine, making it convenient for quick scripts and simple data munging. This is the original 1.00 release.

Amazon::Credentials is a small utility for Perl that finds and returns AWS credentials by trying a configurable chain of providers such as environment variables, container endpoints (ECS, Fargate, Lambda, EKS pod identity), EC2 instance profile metadata (IMDSv2), web identity OIDC tokens, and local ~/.aws config and credentials files, and it provides a simple object API plus a command line helper to format or export the discovered credentials. You can control the search order, timeouts and caching behavior, check token expiration and refresh renewable credentials, and it supports SSO flows, credential_process helpers, and normalization of STS assumed-role ARNs to IAM role ARNs for use with IAM APIs. The module is designed with security in mind so credential values are kept inside closures to avoid accidental leakage via dumps or logs, and logging was recently reworked to further reduce the risk of exposing secrets. Version 1.4.0 also improves SSO handling and always uses regional STS endpoints for web identity exchanges. One current limitation is that it does not automatically resolve chained profiles that use role_arn and source_profile or credential_source in ~/.aws config.

Reaper provides a simple, reliable way to handle child process exits in Perl by installing a $SIG{CHLD} handler that can be used globally or scoped locally to a block. It lets you wrap code in reaper { ... } so any children that exit while the block runs are caught and their exit status recorded, and it supplies reapPid to register specific process IDs to reap and pidStatus to retrieve a recorded exit status. The module supports chaining of handlers so it does not blindly replace existing handlers and it avoids stealing exit codes by only reaping PIDs you register. It does rely on cooperating code not to install conflicting handlers, but otherwise makes preventing zombie processes and capturing accurate child exit codes much more straightforward than ad hoc signal handling.

Mail::JMAPTalk is a small, pragmatic Perl client for talking to JMAP servers that wraps HTTP::Tiny and handles JSON encoding, decoding and basic authentication so you can issue raw JMAP method calls without a heavy framework. It provides helpers to build and send method invocations (CallMethods and a single-call Call), upload and download binary blobs, and perform non-standard JMAPAuth login to obtain a token, but it does not implement high-level mail object models so it is best suited to scripts or applications that need direct control of the JMAP wire protocol. Upload will attempt to detect a MIME type via File::LibMagic if available and otherwise falls back to application/octet-stream, extra headers are supported, and verbose request/response logging can be enabled with DEBUGJMAP. A recent important change adds an accountId option and accessor so the client can automatically include the required accountId on calls that omit it, which helps conform to RFC 8620 and avoid servers rejecting requests.

Antybrowser::SDK is the official Perl client for the Antybrowser Local API that lets you control a running Antybrowser desktop app from Perl. It provides easy access to system status and settings and to manage profiles, automations, groups, proxies and extensions, including creating, updating, starting and stopping profiles and running automations. The module talks to the local API on a configurable port (default 5173) and requires an Antybrowser API key and the desktop app running with the Local API enabled. Methods return decoded JSON hashrefs and the client dies on non-2xx responses, so wrap calls in eval to handle errors gracefully. Installable from CPAN, this SDK is a handy choice for Perl developers who need to script, automate or integrate Antybrowser functionality into their tools.

Antybrowser is the official Perl SDK for the Antybrowser Local API, offering a simple client to access the service from Perl programs. You create a client with your API key and call methods such as get_profiles to retrieve browser profiles and related data exposed by the local API. It is intended for Perl developers who want to integrate Antybrowser functionality into scripts or automation tasks. The module is provided by Antybrowser.com and is released under the MIT license.

SPVM::Sys is a cross-platform, system-level utility for SPVM that gives you direct access to file and directory operations, low-level file descriptors, sockets and network primitives, time and clock functions, process control and signals, and user and environment database access via a set of static methods. It wraps common POSIX and platform APIs so you can open, read, write, and manage files and directories, control sockets and TCP keepalive settings, fork and exec processes, examine file attributes with Perl-style -X tests, and manipulate environment variables and user/group entries. The module handles Windows UTF-16 to SPVM UTF-8 filename conversion and sets close-on-exec flags where supported to help portability and safety, and it bundles many related submodules for ioctl, select, stat, time, and socket address handling. Use SPVM::Sys when you need reliable, low-level system calls from SPVM as the foundation for networking, file IO, process management, or building higher-level libraries.

Test::Load::Helper automatically finds and loads a test helper file by walking up the directory tree from the calling test, so you can avoid hardcoded relative requires. It evaluates the helper inside the target package with strict and warnings enabled, supports a custom filename or relative path via the file import option and lets you load helpers into a dedicated package via the into option. Helpers can chain to their parent helpers so local and shared fixtures accumulate, and the module deduplicates loads so the same helper is not evaluated twice into the same package. Traversal can be bounded by setting TEST_LOAD_ROOT to prevent crossing project boundaries, and if no helper is found the module quietly does nothing. Recent work lowered the required Perl version to 5.10.

Clipboard::Any provides a simple, uniform Perl interface for working with the system clipboard across several Linux desktop clipboard managers. It detects or accepts a specified backend such as KDE Plasma Klipper, clipit, parcellite, or xclip and exposes operations to add or clear the current clipboard, clear the full history, list history items, fetch a specific history entry, and detect which manager is running. Each operation returns an "enveloped" result array with an HTTP-like status code, a reason string, an optional payload and optional metadata so your scripts can handle success and errors consistently. Be aware that xclip is treated as an X selection interface with primary and secondary selections rather than a full history and that Klipper cannot return non-text items like images through its text APIs, so history and non-text behavior varies by backend. This module is handy when you need cross-manager clipboard handling in command-line tools or automation on Linux and welcomes contributions to add support for more environments.

Nmap::Scanner is a Perl wrapper for the nmap network mapper that lets Perl programs launch scans, capture nmap XML output, and work with the results as native objects rather than parsing text. You can build scans by setting options and targets and run them in batch mode to get a Results object containing Host and Port objects, or use event mode and register callbacks to be notified as hosts are discovered, ports are found, scans start and finish, or when hosts are closed or have no open ports. The module mirrors nmap's XML model so services, OS guesses, addresses and other data are available through simple accessor objects, making it easy to integrate scanning into larger OO Perl projects or automation scripts. It requires a local nmap installation (nmap 3.10+ to use all features) and supports running scans from files or via the nmap binary. Recent updates improved XML error reporting by using open3 and added task, task progress, and distance objects plus event hooks for task start/stop and progress, which helps build responsive GUIs or progress-aware tools.

Git::MoreHooks is a collection of extra Git hook plugins that extend the Git::Hooks framework to add checks and integrations you can enable from your git config. The bundle provides useful hooks such as Perl code checks (currently via Perl::Critic), commit author validation against mailmap entries, indentation checks with per-file exceptions, Jenkins build triggers, repository administration helpers and a recently added ScanCtags hook for ctags scanning. It is intended to be used through Git::Hooks and requires Git::Hooks 2.8.0 or later and Log::Any for logging, while several hooks have optional feature dependencies like Perl::Critic, Jenkins::API and Git::Mailmap that are loaded at runtime and reported if missing. The project is actively developed so behavior may change between releases, and the author has improved robustness by making optional modules load dynamically and report errors instead of crashing.

PGXN::API is a ready-made toolkit for hosting the PGXN REST API and serving a browsable, JSON-based mirror of PostgreSQL extensions. It syncs a mirror via rsync, merges and enriches the mirror metadata, converts README and other docs to cleaned HTML, builds full-text search indexes and exposes those resources through a Plack-based web server you can run with pgxn_api_server. Use pgxn_api_sync in a cron job to keep the document root up to date and point the server at that directory to provide the API, browseable source files, and search endpoints. The module works with PGXN::Manager for mirror creation and with WWW::PGXN for client access, and its indexer recognizes multiple doc formats and generates per-distribution and per-user JSON files for easy consumption. Recent releases improved Markdown handling by switching to Text::Markdown::Discount so code fences, tables and definition lists render correctly and added a few more allowed HTML elements, and the project has removed macOS support where native dependencies no longer build. If you want to run your own PGXN-compatible API or build a similar lightweight distribution mirror with search and documentation rendering, PGXN::API gives you the sync, indexing and server pieces you need.

Matplotlib::Simple is a Perl wrapper that lets you generate matplotlib charts from native Perl data structures by emitting a Python3 script and running it to produce image files, giving a compact, consistent API and helper functions for common tasks so you do not have to write Python plotting code by hand. It accepts hashes and arrays as input and supports single and multi-panel layouts, overlays, legends, colorbars and many plot types such as bar, plot, scatter, hist, hexbin, imshow, violin and a “wide” summary for repeated runs, and it can write editable Python files to the system temp directory or execute them for you. The module requires a Python 3 interpreter and matplotlib and optionally matplotlib-venn for proportional Venn diagrams. The recent 0.312 release fixed important correctness issues in the wide summary by sorting runs before interpolation, limiting each run’s contribution to its own x-range and adding better validation, and it also improved how data-derived labels are escaped so keys containing quotes or backslashes are emitted safely as Python string literals. If you prefer to drive high-quality matplotlib output from Perl without hand-coding Python, Matplotlib::Simple streamlines that workflow.

Data::FormValidator::Constraints::NumberPhone provides small, ready-made constraint functions you can plug into Data::FormValidator to validate telephone numbers using Number::Phone. It includes FV_american_phone for easy validation of North American numbers (US and Canada) and a more general FV_telephone that takes a list of country codes to define which national formats are allowed. FV_telephone accepts no countries by default so you must supply the ones you want. If you already use Data::FormValidator and need reliable phone-number checking without writing your own code, this lightweight wrapper makes integration with Number::Phone simple.

Punk::Challenge provides a lightweight proof-of-work gate for Punk applications that asks a visiting browser to solve a small JavaScript puzzle and then issues a signed clearance cookie proving the client solved it. It ships as a Punk plugin and exposes a challenge keyword and guards so you can require the puzzle before sensitive pages such as login or deploy it as a softer alternative to outright rate limiting. The approach needs no third party, no images and no human interaction because the work is done in the browser and verified by the server. Use it together with Punk::Challenge::Token for token handling and to sit in front of Punk::RateLimit when you want to avoid returning 429 responses. This is the module's initial public release.

Authen::SASL is a Perl framework for handling SASL authentication so your client or server code can negotiate standard login methods and optional connection security without reimplementing protocol details. It exposes a simple API to select mechanisms, supply credential callbacks, and perform the stepwise challenge/response exchange used by protocols like SMTP and IMAP. The module is pluggable so it will try to load a high performance XS backend that wraps the Cyrus SASL C library first and fall back to a pure-Perl implementation, or you can force a specific plugin yourself. It also supports SASL security layers where available, exposing properties such as ssf and methods to encode, decode, or wrap sockets for encrypted I/O. If you are building networked applications that must support multiple SASL mechanisms or want a reusable, protocol-agnostic authentication layer, Authen::SASL provides the tools to do that with minimal integration work.

Net::IP::LPM is a Perl library that implements fast Longest Prefix Match for both IPv4 and IPv6, letting you store IP prefixes with associated values and quickly find the most specific match for a given address. You add prefixes with add and then perform lookups with lookup or the faster lookup_raw after rebuilding the internal table, and you can inspect the trie with info or dump and clear it with finish. The module uses a trie-based algorithm and is optimized for large routing tables, with real-world performance on the order of a million lookups per second on common hardware. It is a mature option when you need high-speed IP prefix matching for routing, IP classification, or similar tasks and recent releases include security fixes that improve prefix validation and bounds checking.

Plack::Middleware::Greylist is a Plack middleware that rate limits HTTP requests by client IP or network block so you can throttle abusive clients or allow trusted networks higher throughput. You configure a default per-minute rate and a greylist of CIDR blocks that can be whitelisted, blacklisted, given a specific numeric rate, or assigned special handling such as a "norobots" rule that only allows robots.txt. Limits can be applied per individual IP, per entire netblock, or grouped under a named bucket so multiple ranges share a quota. Counts are stored in a shared cache file by default using Cache::FastMmap so the middleware works across processes and it returns HTTP 429 with a Retry-After header when a client exceeds its quota. You can also supply a callback to handle or log blocked events instead of the built-in logger. The module requires Perl 5.20 or later and notes some caveats such as not enforcing consistency between overlapping netblocks, potential odd merges when using Config::General, and the fact that some crawlers may ignore HTTP 429 responses.

Novel::Robot is a small toolkit for automating the collection and repackaging of web fiction, aimed at developers who want to fetch, parse, and bundle online novels for offline reading or further processing. Its Browser component handles retrieving pages and following links with basic navigation helpers. The Parser component extracts structured content such as chapter titles, body text, and simple metadata from fetched HTML. The Packer component assembles parsed chapters into single outputs for distribution or archiving, such as concatenated text or simple ebook formats. The modules are useful if you need a straightforward, code-first way to scrape and organize serialized fiction from the web for personal use or integration into larger workflows.

Open::API is a Perl toolkit that reads an OpenAPI 3.0 or 3.1 document, compiles every parameter and schema into JSON::Schema::Fast validators and uses that single compiled contract to power both a PSGI server and a spec-driven HTTP client. Routing and request validation run on a C hot path for low overhead, and the library exposes match and validate_request for integration with other frameworks while Open::API::Plack and Open::API::Client provide ready-made server and client implementations. It upconverts OpenAPI 3.0 schema dialects into a 3.1 shape at load so tooling and validation see a single schema model, expands discriminators into precise branch checks, and can synthesize deterministic mock responses from the spec. The module also offers response checking and coverage counters for sampled runtime validation, and it installs a public C ABI header so other XS dispatchers can route and validate without a Perl frame. Recent fixes include a relaxed ABI version check to improve compatibility when provider and consumer tables evolve.

Fetch is a high-performance HTTP client for Perl that gives you an async-first user agent with HTTP/1.1 and HTTP/2 support, connection pooling, streaming response bodies and native WebSocket support. Every request returns a Fetch::Future so you can write simple synchronous code with ->get or scale to thousands of concurrent requests by driving a supplied event loop or plugging into IO::Async, AnyEvent or Hyperman. It includes conveniences you expect from a modern client such as per-request timeouts, TLS verification, a cookie jar, JSON request/response helpers, redirect handling, on_headers/on_body streaming callbacks and a lean simple_response mode for very high-throughput consumers. Fetch also exposes a C ABI for embedding in XS modules and provides an on_request observer hook plus a clone facility to share connection pools while isolating options like cookie jars. A recent notable improvement is that Fetch::Future now implements the Future::AsyncAwait awaitable API so requests work naturally inside async subs and you can attach on_cancel handlers to futures.

GitHub::Actions is a small helper for writing GitHub Actions steps in Perl that exposes the runner's GITHUB_* environment variables and provides lightweight wrappers around GitHub workflow commands. It gives you simple functions to set environment variables and step outputs, emit debug, warning and error messages, report errors with file and line info, group log output, append Markdown to the job summary and control the step exit status. The module is intentionally minimal and dependency free so you can use the system Perl on GitHub runners or install it via CPAN or include it in your repo with fatpack, and it is used from a step with shell: perl {0}. Remember to call exit_action when you want the step to fail after reporting errors and note that job summaries are concatenated from all steps which can introduce blank lines and may affect some Markdown constructs like tables.

Punk::Push adds Web Push notification support to the Punk web framework so you can send browser push messages from your app by registering VAPID keys and calling a simple push_send helper from request handlers. It integrates with the Punk::Plugin::Push plugin for configuration and helpers and relies on VAPID for the RFC 8291 encryption and RFC 8292 identification used by modern Web Push services. If you build web apps with Punk and need to notify users in real time from the server, this module provides a compact, framework-native way to do that. This is the initial 0.01 release and the code is available under the Artistic License 2.0.

Developer::Dashboard is a local “home” for development that brings your browser, shell prompt, and CLI under one consistent runtime so links, notes, repeatable actions, health checks, file and path shortcuts, Docker Compose workflows, and lightweight data queries live behind a single entrypoint instead of scattered scripts and tabs. It provides a small web UI (default 127.0.0.1:7890), a prompt integration that shows cached indicator state prepared by background “collectors”, a CLI with helpers like jq/yq/tomq/open-file/workspace, a bookmark-style page engine with Template Toolkit and isolated CODE blocks, layered per-project overrides (DD‑OOP‑LAYERS), and an extensible “skills” system so teams can add project-local commands, pages and docker roots without touching system paths. The tool is written in Perl but is language-agnostic in its helpers and works well in mixed-language repos; runtime state is file-backed so prompts and the web UI remain fast by reading prepared results rather than re-running probes. Recent 4.30 fixes are notable: session records with missing expiry are now rejected and swept, misconfigured collectors no longer fork runaway workers, and the in-process d2() helper was changed to a lazy dotted-proxy form that requires a terminating ->() call (an intentional, documented incompatibility for embedded users).

App::Netdisco is an open source, web-based network management tool that discovers and inventories equipment by polling devices via SNMP and storing the results in PostgreSQL. It helps network teams quickly locate a host by MAC or IP and see the exact switch port, perform port actions such as shutdown, VLAN and PoE changes, generate inventories by vendor, model and OS, and visualise topology with interactive maps. The distribution includes a browser UI with a built-in web server, a backend daemon for scheduled collection and job handling, command line utilities for ad-hoc work, a plugin system and an API for customization, and it is available as container images for easy deployment. It requires Perl 5.10+ and PostgreSQL 9.6+ and provides documentation and community support for installation and tuning. Recent releases streamline deployment by reducing container image size and make the device Ports view much faster and more responsive.

Desktop::KDE::Util is a small helper library for Perl developers who need basic utilities when working with the KDE desktop. Its primary provided routine, which_qdbus, searches your system for qdbus binaries and returns their paths so your script can locate and invoke KDE's D-Bus command-line tool. The function is available for import but not exported by default. This is an early, focused release refactored from Desktop-KDEActivity-Util, so it is lightweight and best suited to scripts that simply need reliable discovery of qdbus rather than a full KDE integration framework.

Music::Percussion::Tabla is a Perl module for programmatically generating tabla rhythms as MIDI using a bundled 4.1MB Tabla.sf2 soundfont and a simple API of strikes, rests and preset thekas (groove patterns) like teentaal, dadra and rupaktaal. You work at a high level with named bols such as ta, ge, ke and composite double-strikes like dha, and the module maps those names to one or more MIDI patches and picks patches at random for natural variation. It supports simultaneous notes, custom patch numbers, duration helpers (for example eighth or sixteenth) and a write() method to save the generated score as a MIDI file, and the docs include instructions for using the soundfont with common synths such as FluidSynth. The strike() method now returns MIDI note specifications so you can handle notes externally and the module exposes the default patch mappings while letting you override or address patches directly. A few patch syllable names are noted as unknown by the author, but otherwise this is a practical tool if you want to script authentic tabla patterns from Perl without handcrafting MIDI events.