CPANscan

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.

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.

CXC::Exporter::Util is a small helper library for Perl modules that export symbols. It is not an exporter itself but provides tag-centric utilities that centralize export definitions in %EXPORT_TAGS and automatically populate @EXPORT and @EXPORT_OK so you do not forget symbols or duplicate lists. It also makes it easy to define named groups of constants with install_CONSTANTS, generating the constant functions and companion enumerator functions that return either the constants values or their names, which is handy for iteration or building type enums. A companion install_EXPORTS call folds those enumerators into the export tags and finalizes the exports. Optional UI helpers let a program accept human friendly names for constants and coerce them back to values, and those helpers are available when Exporter::Tiny is present. The module is simple and pragmatic and helps keep export metadata in one place but it does not itself detect or warn about name clashes between enumerator functions and constant functions.

App::karr is the engine behind karr, a Git-native kanban tool that keeps your board state inside Git refs (refs/karr/*) rather than in repository files, so task cards live as Markdown payloads with optional YAML frontmatter and changes are serialized back into refs to avoid file-level merge conflicts. The installed karr CLI presents a transient, materialized board view for each command and implements common operations like create, list, move, archive, backup and restore, while lower-level modules such as App::karr::Git, App::karr::BoardStore and App::karr::Task let you script and automate board inspection or manipulation from Perl. The project ships Docker images for easy vendoring and runtime isolation and the recent 0.300 release bundles libgit2 into the runtime image and adds karr-foundation, a single-shot daemon for periodically running agent commands across multiple karr boards. If you want Git to remain the transport and source of truth for task state and prefer a CLI or programmable API that works directly with Git refs, App::karr is a lightweight, practical choice.

App::CriticDB is a utility and Perl module for scanning large codebases with Perl::Critic and keeping a persistent store of policy violations so you can update files incrementally and produce quick reports without re-running Perl::Critic across everything. It currently stores violations in a local file using Storable, records file mtimes to skip unchanged files, removes entries for deleted files, and provides a perlcritic-like reporting interface to STDOUT plus a command line tool perlcriticdb. The tool is aimed at speeding up policy counting and ongoing analysis of large repositories and the author plans additional features such as more storage backends, finer-grained change detection, richer reporting hooks, and improved command line filtering. If you need to aggregate, cache, and report Perl::Critic findings for many files, this module simplifies and accelerates that workflow.

Git::Native is a lightweight Perl interface for working with Git repositories directly via libgit2 without spawning the git command. It is a Moo-based wrapper around Git::Libgit2 that uses FFI::Platypus so you can open or init repositories, create blobs, build trees and create commits programmatically inside your process. It provides convenience methods like open, open_ext, init and reference_name_is_valid so common repository tasks are simple and fast. Use it when you need native, non-forking Git operations as an alternative to modules that shell out to git. The author positions it against Git::Wrapper and Git::Repository which run the git binary, Git::Raw which is XS and unmaintained, and Git::PurePerl which is read-only.

Cpanel::JSON::XS is a cPanel-maintained fork of JSON::XS that provides fast and correct JSON encoding and decoding for Perl, implemented in C for high performance. It focuses on proper Unicode handling and preserving round-trip integrity while being strict and secure by default, though it offers many configurable modes for ASCII, latin1, binary, relaxed parsing, big numbers, and object serialization via TO_JSON or a tagged FREEZE/THAW protocol. The module supports incremental streaming parsing, detects BOMs, is thread safe, and is the backend that JSON::MaybeXS will pick when available, so it is a good choice when you need a battle-tested, high-performance JSON tool for Perl. The project is publicly maintained on GitHub with a bug tracker and the author notes it will be replaced by a JSON::Safe module in the future to provide safer defaults.

SignalWire is the Perl port of the SignalWire AI Agents SDK that helps you build, deploy, and run AI agents as small web services that expose HTTP endpoints and connect to the SignalWire platform. It gives a structured prompt model for composing agent prompts, lets you define local tool handlers in Perl or declarative DataMap tools that call external APIs without webhooks, and includes a skills system, context management for multi-step flows, ready-made agent prefabs, a multi-agent HTTP server, a WebSocket Relay client for real-time call control, and a REST client for synchronous API access. You can add capabilities like datetime, math, or web search, host multiple agents in one process, and wire handlers to return structured function results that your agent uses when interacting with users. The module expects SignalWire credentials via environment variables and is available under the MIT License from the project repository at https://github.com/signalwire/signalwire-agents-perl; note the POD mentions a minor documentation encoding glitch.

RT-Extension-AI brings generative AI into Request Tracker to help summarize ticket conversations, assess sentiment, suggest or rewrite responses, autocomplete editor text, translate content, and even guide administrators through creating new queues. It installs as an RT6 plugin and connects to any REST-based AI provider such as OpenAI or Google Gemini with configurable prompts, models, and per-queue settings so you can tune behavior and limit features where needed. The extension provides scripted actions that update ticket custom fields, editor integrations via a CKEditor plugin that insert AI suggestions into replies, and optional context files of past tickets to improve suggestion quality. Setup follows the standard Perl module installation and includes sample configuration showing provider credentials, feature flags, and prompt templates. Be aware that some editor features may call the AI service frequently and that provider authentication or small provider-specific adjustments may be required.

Geo::Coder::OpenCage is a Perl client for the OpenCage Geocoding API that makes forward and reverse geocoding easy to use from Perl programs. You provide an API key and call geocode with a location string to obtain coordinates or reverse_geocode with latitude and longitude to obtain address details, and the module returns a parsed Perl hashref containing status and results. It supports common API options such as language, result limit and country hints, uses HTTP::Tiny by default but lets you supply a custom HTTP client, and it always sets a module-specific User-Agent header. Responses are parsed for you so JSONP is not used and you should check the response status to detect errors or rate limits. If you need programmatic access to OpenCage geocoding from Perl this module provides a straightforward, ready-to-use interface.

Catalyst::Plugin::OpenIDConnect is a Catalyst plugin that enables your application to act as an OpenID Connect provider (authorization server), not as a client. It supplies the standard OIDC endpoints (discovery, authorize, token, userinfo, jwks, logout), RS256 JWT signing and verification, state and one-time code storage, and hooks for your controllers so you can integrate your own login flow and routing by extending the plugin controller. Configuration is done in your Catalyst config with issuer keys and client entries, and the plugin supports pluggable stores including an in-memory backend and a Redis-backed store for multi-process deployments. Recent releases focus on production-grade security hardening, adding PKCE for public clients, refresh-token rotation with server-side JTIs, stricter JWT claim validation and constant-time secret checks, fixes for open-redirect issues, and automatic HTTP security headers on OIDC responses, making it a solid choice when you need a configurable, secure OIDC authorization server inside a Catalyst app.