CPANscan

Net::RCON::Minecraft is a lightweight Perl client for Minecraft's RCON remote console that lets you script server administration by sending commands and receiving their text responses. It manages TCP connection and authentication, handles fragmented replies, and returns a Response object with methods to get the raw text, a version with Minecraft color codes removed, or an ANSI-converted form for terminals. The API is simple: you can let it auto-connect on first command or explicitly connect and disconnect, set read timeouts, and handle errors via eval. Be aware that RCON grants operator-level access so you should use a strong password and firewall rules, and avoid RCON on unpatched vanilla servers older than 1.14.3 because of a known crash bug. As of version 0.04 the project now uses GitHub for issue tracking.

Spreadsheet::Edit is a Perl toolkit for loading, inspecting and transforming tabular data from CSV files or spreadsheet formats and for building sheets in memory. It makes columns easy to address by title, letter or automatic aliases and can tie package variables to columns so that inside an apply block you can read and write cells as ordinary scalars while rows behave as either arrays or hashes for flexible random or sequential access. You can insert, delete, move, split and join columns, sort or transpose rows, perform row-wise processing with handy magic variables, and write results back to CSV or create new spreadsheet files. The module auto-detects title rows, CSV encodings and separators and recent releases improved CSV import and spreadsheet conversion to preserve text, dates and leading-zero values when round-tripping to spreadsheet formats. It does not preserve cell formatting and reading spreadsheet files can fail if LibreOffice/OpenOffice is running, and thread safety is unknown.

Date::Find is a compact Perl utility for locating and extracting year, month and day sequences from filenames or other short strings, useful for organizing files by date or parsing timestamps embedded in names. It supports common date orders like ymd and dmy, returns matches as simple hashrefs via find_ymd, can report all found date patterns with find_all_ymd, and can group or guess the dominant format across many items with guess_date_format and guess_ymd. You can control behavior with options such as mode (strict or lax), a preference order for ambiguous formats, and which components to extract, and the module accepts dots or dashes as date separators. Recent updates fixed strict-mode extraction and added a few usability improvements, so it should behave robustly when deciding which date to prefer. For broader text extraction or timestamp-with-timezone needs consider Date::Extract or Filename::Timestamp.

Net::Async::Crawl4AI is an IO::Async-compatible, non-blocking client for the Crawl4AI service that wraps the synchronous WWW::Crawl4AI orchestrator and exposes the same high-level crawl and markdown workflows as Future-returning methods. It runs the Crawl4AI strategy chain asynchronously so you get the same WWW::Crawl4AI::Result objects without blocking an event loop. You can perform single-shot requests like crawl_once, md, screenshot, pdf, html, execute_js, llm and token, submit and poll crawl jobs with job_submit and job_status, or run the full async strategy via crawl or markdown. It also offers an asynchronous breadth-first deep_crawl that follows links with configurable concurrency and preserves per-page result objects. The module integrates with Net::Async::HTTP, honors the underlying client's retry policy, supports async callbacks that may return Futures, and requires adding the watcher to an IO::Async::Loop before use. This initial release focuses on providing the non-blocking client surface, job polling helpers, and concurrency-aware deep crawling for existing Crawl4AI deployments.

WWW::Crawl4AI is a Perl client and orchestrator for a self-hosted Crawl4AI service that runs a configurable chain of crawling strategies and returns a normalized, agent-friendly result object. It escalates from cheap headless fetches to full browser renders and stealth modes, with optional CloakBrowser attachment, proxy runs, or a user callback, and stops as soon as its classifier deems a page acceptable. Every attempt is modeled and recorded so you can see which backend produced the final page, the cost class, the final URL, and a complete attempt history with failure reasons. The module offers single-action methods for screenshots, PDF, preprocessed HTML, JS execution, LLM queries and JWT tokens, a health check, and a breadth-first deep_crawl that follows extracted links with options for max pages, depth, host restriction, URL filtering and per-page callbacks. Configure it with base_url, api_token, optional cloakbrowser or proxy endpoints or a callback coderef, fallback policies, timeouts and other tuning, or inject your own low-level client for raw REST use. Use WWW::Crawl4AI when you operate a Crawl4AI server and want cost-aware progressive crawling with transparent fallbacks and per-request diagnostics.

JQ::Lite is a pure-Perl implementation of a jq-like JSON query engine that gives you familiar dot-notation, filters, piping, and a large set of built-in functions for extracting, transforming, aggregating, and filtering JSON without needing the external jq binary or any compiled modules. It works as a library and as the jq-lite command line tool, supports optional safe key access and array helpers, returns native Perl scalars and references, and can use JSON::PP by default or alternate JSON decoders if available. The module is designed for minimal, restricted, or air-gapped environments such as lightweight containers, CI systems, legacy servers, and places where installing jq is not possible. It also includes an interactive REPL for experimenting with queries and many of jq's common helpers like map, select, walk, sort_by, group_by, and tojson/fromjson so you can port many jq workflows into Perl code or scripts.

Encode::Bijou64 provides simple, easy-to-use routines to convert non-negative integers to and from the Bijou64 variable-length byte encoding developed by Ink & Switch. It exports two functions, encode_bijou64 and decode_bijou64, so you can turn integers into compact byte strings and recover them later, with small values using fewer bytes and the format designed for fast decoding. Use this module when you need space-efficient storage or transmission of integers in Perl programs, for example in custom protocols or compact file formats.

Crypt::SMIME is a Perl class for handling S/MIME email tasks using OpenSSL's libcrypto, letting you sign, verify, encrypt and decrypt MIME messages from your Perl code. You create an object, load private keys and certificates from PEM or PKCS#12 and place trusted cert stores for verification, then call sign to make a detached S/MIME signature or encrypt to produce an S/MIME-encrypted message, and use check and decrypt to verify signatures or recover the original MIME content. The module can also detect whether a message is signed or encrypted, extract included certificates and signer certificates, report S/MIME capabilities, and lets you adjust verification time and CRL-checking behavior with flags. Defaults are sensible, for example AES-128-CBC is the default cipher, and the API will die on failures so errors are surfaced immediately, making this a practical choice when you need straightforward S/MIME support in Perl.

Lemonldap::NG::Portal is the portal component of the Lemonldap::NG Web Single Sign-On system that lets you add centralized authentication, authorization and accounting headers to protect web applications with minimal changes. It runs as a PSGI/Plack application and wires together modular plugins for authentication, user databases, second factors and issuers so you can mix and match LDAP, CAS, Apache-based auth and other backends. The portal handles full login flows, Ajax JSON and HTML responses, redirections and template rendering, and supports features like single logout, notification, password management and a double session mechanism. Configuration is reloadable at runtime and plugins are initialized from that configuration, so extensions must follow the portal plugin rules and treat configuration as read-only during requests. If a plugin fails initialization the portal will respond with an error, but the plugin model makes it straightforward to add custom auth or userDB modules. For more details and downloads see the Lemonldap::NG project site.

Lemonldap::NG::Manager is the web-based administration component for the Lemonldap::NG Web Single Sign-On system that exposes a REST API and ships a JavaScript (AngularJS) frontend so administrators can manage configurations, sessions, notifications and second-factor settings from a browser. It runs as a PSGI/Plack application so it is compatible with CGI, FastCGI and similar environments and includes tools for building the configuration UI and static assets. You can point it at your lemonldap-ng.ini or override options programmatically and control behavior such as access protection, enabled modules, logging level, language and template locations. The project is mature and historically moved away from a SOAP server toward a REST/portal approach, and documentation and the REST-API.md file in the source tree describe the available endpoints and UI structure. If you operate a Lemonldap::NG deployment and need a ready-made management console with a CLI and REST backend, this module is directly relevant.

Lemonldap::NG::Handler is the Apache protection module for the Lemonldap::NG Web‑SSO system and in this distribution acts as an alias for Lemonldap::NG::Handler::ApacheMP2. It sits in front of web applications served by Apache and enforces single sign‑on, session management and access rules, handling authentication, redirects, logout and header injection so protected sites do not need to implement their own SSO logic. It supports Apache 1 and 2 usage patterns, can protect CGI apps, work with shared configuration backends and cross‑domain setups, and includes helpers such as auto‑login for Sympa and proxy/POST login options for non‑compatible apps. Recent releases added CDA support in core, moved basic auth to SOAP, improved logging and introduced a double‑session mechanism. If you need to add centralized SSO and request‑level protection to sites served by Apache, this module is the appropriate component of the Lemonldap::NG stack.

Lemonldap::NG::Common provides the shared utilities and building blocks used across the LemonLDAP::NG Web single sign‑on suite, consolidating common configuration and runtime helpers for the Manager, Portal and Handler components. It collects reusable code such as SOAP wrappers and a WSDL builder, logging adapters for Apache2::Log and syslog, LDAP-backed storage for sessions and configuration, a cryptography object, a setApacheUser helper and a small safelib of rule utility functions so developers can extend or deploy LemonLDAP::NG without duplicating infrastructure code. Recent releases notably added SOAP/WSDL support, LDAP storage backends and improved logging wrappers. The module is part of the LemonLDAP::NG project, distributed under the GPL, with source, downloads and bug reporting available via the project website and OW2 GitLab.

Time::Str is a Perl module that makes it easy to parse and format date and time strings across a wide range of standards, turning human-readable timestamps into Unix epoch numbers or into detailed date components and turning epochs back into standard-formatted strings. Its three main routines are str2time to produce numeric timestamps with optional fractional seconds, str2date to return parsed components without forcing a timezone conversion, and time2str to format epochs with control over timezone offset, precision, and explicit nanosecond output. It understands ISO 8601 and its profiles such as RFC 3339 and RFC 4287, common Internet formats like RFC 2822 and HTTP dates, SQL and ASN.1 forms, iCalendar, ECMAScript, Common Log Format and several Unix/Git/Ruby styles, and it includes a permissive DateTime parser for many real-world variations. Timezone handling requires either a UTC designator or a numeric offset to produce an epoch, while timezone abbreviations are captured but intentionally not resolved by the module so you can handle ambiguous zones yourself. Fractional seconds are handled carefully with truncation on parse, rounding on format, and a nanosecond parameter for exact subsecond control, and the module interoperates cleanly with DateTime, Time::Moment and Time::HiRes. An optional XS (C) backend is used when available for performance with a Pure-Perl fallback, and you should be aware of a few limits such as English-only month and day names, no ISO week or ordinal dates, a supported year range of 0001 to 9999, and the deliberate choice not to map ambiguous timezone abbreviations to offsets.

Class::Utils is a tiny toolkit for Perl classes that makes handling hashref-based object parameters safe and predictable. It provides simple routines to apply key/value argument lists to an object, to fail fast on unknown keys, to ignore private keys that begin with an underscore, and to split incoming arguments into those that belong to the object and those that should be passed on unchanged. Use set_params to enforce allowed keys, set_params_pub to set only public (non-underscored) keys, set_split_params to assign known keys while returning the rest, and split_params to separate a specified set of object keys from other arguments. This module is useful when writing constructors or methods that accept mixed parameter lists and you want clear, defensive parameter handling. The most recent release focuses on documentation and metadata updates.

Graphics::Framebuffer is a pure-Perl graphics library for drawing directly to a Linux console framebuffer, offering a simple, immediate API for pixels, lines, shapes, filled primitives, gradients, TrueType text, image loading, animated GIF playback, blitting and basic transforms. It is aimed at developers who want lightweight, console-only graphics without X or a full GUI stack and exposes dozens of easy methods that take hashref parameters for speed. The module can use Imager and optional Inline::C acceleration to speed costly operations, supports multiple draw modes like normal, XOR, mask and alpha, and includes an emulation mode so you can develop offscreen on systems without a framebuffer. Important caveats are that it only works on framebuffer-capable drivers in a real console session, proprietary GPU drivers that do not expose a framebuffer will not work, and 24/32 bit modes are strongly recommended over 16 bit for correctness and performance. The package is mature and actively maintained; the current 7.03 release mainly updates documentation and adds a small Easter egg while recent releases improved testing, vsync handling, and added features like a pseudo 3D "ball" primitive and better handling of VirtualBox quirks.

App::PDFLibrarian is a small command-line toolkit for organizing academic PDF papers with embedded BibTeX metadata, letting you import PDFs, edit or rebuild their BibTeX entries, export bibliographies or key lists, replace or remove PDFs, and repair links or convert journal names to ISO4 abbreviations. It integrates with typical Unix tools like poppler-utils and ghostscript and installs via cpanm, so it is a good fit for researchers, librarians, or power users who prefer a scriptable, file-based way to keep a BibTeX-aware library of papers rather than using a heavyweight GUI reference manager.

IO::Compress::Brotli is a Perl module that creates Brotli-compressed data from either a whole buffer or a streaming source, making it easy to compress payloads for storage or web delivery. It provides a simple one-shot function bro that takes a scalar and returns compressed bytes and an object-oriented streaming interface via IO::Compress::Brotli->create that lets you set quality, window and mode and feed data in blocks with compress, flush and finish methods. Note that finish must be called to flush termination data and that the module currently does not implement the IO::Compress::Base interface though that is planned for a future release. The distribution bundles the Brotli library and has seen regular updates for compatibility and build fixes; the most recent 0.021 release reverted a prior low-level change and fixed potential memory leaks in error paths.

Zuzu is a tiny Perl helper for running ZuzuScript code from Perl, offering two simple functions: zuzu_eval to parse and evaluate a ZuzuScript source string and zuzu_evalfile to load a UTF‑8 script file and evaluate it. Both functions accept runtime options so you can control things like allowed modules and library search paths, and they return the result of evaluation or the created runtime. Use this module when you need a quick, one-shot way to embed or execute ZuzuScript from a Perl program without dealing directly with the parser and runtime internals.

App::FilenameKeyValueUtils provides a small suite of command line tools for working with filenames that embed key=value style metadata, built on the Filename::KeyValue conventions. The bundled utilities let you parse filenames to extract keys and values, normalize different representations into a consistent format, modify existing key/value pairs, and add or remove metadata while renaming batches of files. This makes the distribution useful when you need to organize or transform large numbers of files whose names carry structured information, for example photo or dataset collections and automated pipelines, and the tools are designed to be scriptable and easy to integrate into workflows. The project is available on CPAN with source on GitHub and is distributed under the same license as Perl.

Map::Metro::Plugin::Map::Lyon provides a ready-to-use dataset of the Lyon metro for the Map::Metro toolkit so you can load the network, run route queries, or use it for visualization and testing without building the topology yourself. The module encodes the four metro lines A through D and their stations and integrates with Map::Metro via Map::Metro->new('Lyon')->parse or the map-metro.pl command line. The latest release reflects the real-world extension of Line B in 2023 by adding two new stations, so the map stays current for routing and analysis. This is a straightforward convenience plugin for developers who need a realistic public transit graph for Lyon.

Dist::Zilla::Plugin::GitHub::CreateRelease is a Dist::Zilla plugin that automates creating a GitHub Release for your CPAN distribution and uploads the distribution archive to that release, optionally adding a checksum and formatted release notes pulled from SignReleaseNotes, a changelog, or a file. You install it into your dist.ini and run it after your build and tagging steps; it infers the repo and remote but lets you override branch, remote name, title template, draft status, checksum algorithm, and which identity file to use for GitHub credentials. Authentication is handled via Config::Identity::GitHub so you provide a ~/.github-identity (or repo-specific identity) with a personal access token that has write access to repository contents and releases. The plugin is useful if you want a reproducible, configurable step that publishes your CPAN release into GitHub Releases with attached artifacts and readable notes. The recent 0.0009 update fixes repository name detection and a ChangeLog-warning issue and adds a few robustness improvements including Sigstore signing support and JSON compatibility fixes.

DateTime::Format::Natural is a Perl module that converts informal, human-friendly date and time phrases into DateTime objects so your code can understand inputs like "next tuesday at 2am", "tomorrow morning", "10 weeks ago", ranges such as "1 April 10 am to 1 May 8am", and even extracts such expressions from larger text. You create a parser with DateTime::Format::Natural->new and can tweak options like the reference "now" DateTime, numeric date format, time zone, calendar, and whether to prefer or demand future dates. Use parse_datetime to get a single DateTime, parse_datetime_duration (in list context) to get one or two DateTime objects for spans, and extract_datetime to pull parsable date substrings; methods provide success and error information and a trace facility for debugging. Note that parse_datetime always returns a DateTime object even on failure so you should check success, and durations should be handled with parse_datetime_duration rather than parse_datetime. Overall it is a practical, extensible way to accept natural-language date input in Perl programs.

Modern::Open is a small compatibility module that brings modern filehandle behavior to older Perl releases. It autovivifies filehandle variables and applies autodie-style failure handling to open, opendir, sysopen, pipe, and accept so that failed operations die with helpful diagnostics when used in void context, and it enables the safer three-argument form of open on Perl 5.00503 and later. socket() will autovivify the handle but does not autodie and returns the underlying CORE::socket result. The module also forbids bareword filehandles and emits clear error messages for wrong argument counts or unknown modes, making legacy scripts safer and easier to migrate to modern Perl conventions.

Net::STOMP::Client::Wrapper is a compact convenience layer that combines a STOMP client and the RabbitMQ management HTTP API into one easy-to-use interface for common produce, consume, and monitoring tasks. It provides sensible defaults for a single RabbitMQ broker such as host 127.0.0.1, STOMP port 61613, guest/guest credentials, a default vhost and queue destination, and exposes simple methods to connect and subscribe, send messages, and fetch queue stats via management_api_get_queue. The module is aimed at straightforward scripts and services that work with one queue and one server and removes boilerplate so you can quickly stomp_connect or stomp_connect_subscribe, send or wait for frames, and query consumer and message counts. Be aware that the connection methods are intended to be called only once per wrapper instance.

GDPR::IAB::TCFv2 is a focused Perl toolkit for decoding and validating IAB TCF v2.3 consent strings, offering a parser object with full accessors and JSON output, a declarative Validator for per-vendor purpose and legal-basis checks, a CMPValidator that verifies CMP ids against IAB snapshots, a tiny one-liner helper for quick scripts, and a subcommand CLI with JSON/text modes plus a prebuilt Docker image for pipelines. The distribution is considered feature-complete for TCF v2.3 and entered maintenance mode in May 2026 so the maintainer will keep fixing bugs and security issues while welcoming community patches. Common uses include extracting consent fields, automating vendor validity checks, validating CMP lifecycle state, and embedding consent checks into shell or CI workflows. Recent updates improved validator parity with a Go reference implementation, tightened policy-version and disclosed-vendors checks, and added structured failure reasons such as CMPDeleted and CMPUnknown, making the validation behavior more predictable across languages. If you need a reliable, well-tested Perl implementation and convenient CLI/Docker tooling for TCF v2.3 consent handling this module is a practical fit.

Module::Generic is a comprehensive base class for building Perl objects quickly and consistently, providing ready-made typed accessors and mutators (numbers, booleans, datetimes, UUIDs, IPs, files, URIs, nested object and array types), an AUTOLOAD that maps hash keys to methods, and a create_class facility to generate classes and methods on the fly so you can model complex data without writing boilerplate. It bundles helpful utilities for error and exception management (including a Null object to allow safe chaining on error), logging and debug output, ANSI colour parsing for terminal messages, flexible serialization/deserialization via CBOR/Sereal/JSON/Storable backends, and many small helpers such as date parsing, symbol manipulation and ASN.1-like type checks. Performance-sensitive helpers are implemented in XS when available but fall back to pure Perl transparently, and the module aims to be thread-aware for global error storage, however the docs warn that dynamic class creation and symbol-table injection are not safe to perform after threads are spawned so those operations should be done at startup. If you want a feature-rich, extensible foundation for application-level objects and prefer convention and helpers over hand-writing accessors and serialization code, Module::Generic is highly relevant.

SIRTX::Font is a Perl toolkit for reading, writing and editing SIRTX bitmap font files, aimed at developers and tool authors working with terminal or legacy bitmap fonts. It gives you an object interface to load fonts, inspect and manipulate codepoints and glyphs, import glyph images or whole directories, convert PSF and Roman .hex fonts, build alias maps, deduplicate and garbage-collect unused glyphs, and render text to images via Image::Magick. The module also understands named character lists and provides helpers to check or trim a font to common codepage subsets, to auto-generate simple glyphs, and to add or analyse rich metadata such as version, weight, slant, tags and display colour. Many features are marked experimental and most methods will die on error, so SIRTX::Font is best used in scripted workflows and font tooling rather than as an end-user library. The recent v0.07 release expanded metadata support, added import_attributes and import_hex, improved sf-to-html output, and fixed several import and aliasing issues.

DateTime::Lite is a lightweight, drop-in replacement for DateTime that gives you the same API while trimming dependencies and improving common performance hotspots. It provides full calendar and clock arithmetic, nanosecond resolution, ISO/CLDR/BCP47-aware formatting and locale support, and robust timezone handling by reading standard TZif binaries and evaluating POSIX footer rules for future dates. The core math and hot paths are implemented in XS for speed, there is a pure-Perl fallback for systems without a C compiler, and timezone data is stored compactly in an included SQLite database with an optional process-level memory cache to boost repeated zone construction in long-lived processes. DateTime::Lite favors safe error handling by returning errors instead of dying by default and accepts complex locale tags that can even carry a -u-tz- extension to infer the time zone. Be aware that using the bundled SQLite engine introduces some native memory overhead and that you may want to enable the TimeZone memory cache for the best per-call speed in servers. Recent updates improved documentation for extended timezone aliases, made the TimeZone module auto-select the fastest JSON backend with JSON::PP as a fallback on older Perls, and fixed a subtle object-check bug in string equality handling.

Filename::Timestamp is a small utility for detecting and parsing dates and times embedded in file names so you can automate organizing or renaming collections of photos, videos and archives. Its single exportable function extract_timestamp_from_filename scans a name for common camera patterns and ISO‑8601 style timestamps and returns false if none are found or a hash with epoch plus broken‑out fields such as year, month, day, hour, minute and second when a match is found. The module understands explicit timezone offsets and will return tz_offset and epoch, and when no timezone is present it marks the time as "floating" and provides epoch_local and epoch_utc computed via Time::Local, with a convenience ymd field added in the latest release. The function is not exported by default and an "all" option to find multiple timestamps is documented but not yet implemented.

IPC::Shareable lets you tie Perl variables to System V shared memory so multiple processes can access the same data directly instead of passing messages. You can tie scalars, arrays, hashes or objects and store arbitrarily complex structures, with nested references mapped into their own shared-memory segments so deep structures consume additional segments. Data is serialized into the segments using JSON by default or Storable for richer Perl-only types, and the module will fall back to Storable when needed; for best JSON performance install JSON::XS. The API feels like ordinary tied variables but also exposes flock-style lock and unlock methods, optional enforced read and write protections to reduce race conditions, and utilities to inspect, map, remove and clean up segments, tag segments for test suites, and implement single-instance scripts. Note that locks are advisory unless you use the enforcement options, locks are inherited across forked processes, segment cleanup on exit runs only for clean exits unless you handle signals, and segment sizes and counts are limited by your operating system.