CPANscan

Dist::Zilla::Plugin::GitHub::CreateRelease automates creating a GitHub Release for a Dist::Zilla-built CPAN distribution and uploads the distribution archive to that release. It pulls release notes from a variety of sources such as signed notes, a ChangeLog, or a specified file and can wrap notes as code, mark releases as drafts, attach a checksum (SHA‑256 by default), and customize repo, owner, branch, title, and identity selection. The plugin expects that your dist has already been released, tagged and pushed to GitHub and it uses Config::Identity::GitHub for API credentials (supporting per-repo identity files and GPG‑encrypted identity files). If you publish modules to CPAN and also maintain a GitHub repository this plugin saves the manual steps of creating the release and attaching the tarball. Recent updates add extraction of notes via CPAN::Changes and fix repository owner detection and HTTP response handling so it more reliably finds the right repo and release notes.

Dist::Zilla::PluginBundle::Author::Plicease is a ready‑made collection of Dist::Zilla plugins that encapsulates Graham Ollis's preferred build, test, packaging and release workflow for Perl distributions. It wires together common tasks such as gathering and pruning files, creating MANIFEST and metadata, handling README and pod, automatic prereq and version detection, Git tagging and pushing, CI and release-test scaffolding, and uploader hooks, while exposing options like which installer to use, readme source, whether to include release tests, copying Build/MakeMaker files into the repo, allowed dirty files for Git, and platform release restrictions. The bundle is primarily intended to be used for the author's own dists or to make it easy for contributors to reproduce his release setup, and it includes an example/unbundle.pl script and guidance to convert the bundle into editable config if you want to adopt or modify its defaults. Recent notable changes in v2.80 include updated GitHub Actions templates (v6), a raised minimum supported Perl version (now 5.22), and a new starter template for Perl 5.42.

App::sdif bundles three small command-line utilities that make diffs easier to read and track. sdif renders standard diff output in a clear side-by-side layout, cdif adds visual highlighting to show changes at the word or character level, and watchdiff repeatedly runs a command and emphasizes what changed between runs. The tools are designed to plug into common workflows such as using sdif as a git pager and they include options for improved word segmentation with mecab for certain languages. Installable from CPAN with cpanm and configurable via simple rc and git settings, this package is a lightweight way for developers to get more readable, visually informative diffs in the terminal.

Dist::Zilla::PluginBundle::Git::CheckFor is a small Dist::Zilla plugin bundle that runs a set of Git sanity checks as part of your release process, making it easy to catch common mistakes before you ship. By adding [@Git::CheckFor] to your dist.ini you get bundled checks that verify you are on an appropriate branch, detect leftover autosquash commit messages like "fixup!" or "squash!", and look for common merge mishaps, among other repository linting tasks. It simply groups the related Dist::Zilla::Plugin::Git::CheckFor::* plugins so you can enable them all at once, and the recent 0.015 release fixed an @INC related issue and removed a problematic MooseX dependency to improve installation on bleeding‑edge Perls. If you publish Perl distributions with Dist::Zilla and want automated, git-focused pre-release checks, this bundle is a convenient way to add them.

Desktop::XWindowManager::Util provides small, script-friendly utilities for inspecting and manipulating X11 windows with a focus on KDE "activities". It is a thin wrapper around existing command‑line tools such as wmctrl, so it works best with EWMH‑compliant X11 window managers like KWin, Xfwm and Mutter and only partially with minimalist WMs or Wayland sessions that rely on an X compatibility layer. The module exposes functions to list windows with flexible filters, retrieve KDE activity GUIDs for a given window, and move windows between activities, and its functions return a uniform enveloped result containing an HTTP‑style status code, a reason string, the payload and optional metadata which makes it easy to handle success and error cases in scripts. Functions are not all exported by default but are exportable for use in automation or tools that need to query or reorganize windows by title, ID or KDE activity, and recent updates added filters for KDE activity name and current activity as well as support for multiple activity targets when moving windows. Because it delegates work to external utilities, its capabilities depend on the underlying window manager and installed tools rather than trying to implement low level X or Wayland logic itself.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla configuration bundle that wires up the author GETTY's preferred plugins and sensible defaults so you can build, test, and release Perl distributions with minimal setup. It handles versioning, metadata, PodWeaver, Git-based version management and release commits, optional GitHub release publishing, install-after-release, and support for XS or Alien-based C libraries, plus convenient hooks to run scripts before or after build and release. The bundle auto-detects GitHub remotes but can emit generic or Gitea/Forgejo metadata for self-hosted forges, excludes README.md from release tarballs by default, and can also add Docker image build and CI wiring through a shared GitHub Action, so it suits pure-Perl modules, XS modules, and packaged C-library wraps. Configuration options let you opt out of particular behaviors, mark a dist as up for adoption, add IRC support in metadata, restrict which files get $VERSION rewritten, and pass through Alien or Docker settings without manual plugin plumbing. Notable recent change in v0.317 adds a tag_format option so you can control the format of Git tags produced at release time, for example to prepend a v for other ecosystems while keeping Perl version semantics intact.

Net::Firewall::BlockerHelper is a lightweight Perl helper for programmatically managing IP bans across multiple firewall backends. It exposes a simple API to initialize and teardown firewall rules, ban and unban IPv4 and IPv6 addresses, handle CIDR ranges when the chosen backend supports them, list current bans, flush all bans, and reapply rules. The module validates ports, protocols, IPs and CIDRs, offers a configurable self_heal mode that checks and restores the backend setup before each action, and delegates actual rule work to backend implementations such as ipfw. Error handling is done via Error::Helper and failures are treated as fatal, making this module a practical choice for scripts or services that need a uniform way to manage blocking across different firewalls.

POE::Component::Server::JSONUnix is a compact, event-driven server you can drop into a Perl app to expose a simple JSON request/response API over a Unix domain socket. It speaks newline-delimited JSON where each message names a command and carries optional arguments and an id, and handlers are just a dispatch table you register at startup, at runtime, or by subclassing. Handlers may return results synchronously, raise errors, or operate asynchronously by holding a context object and replying later, so it fits both simple control commands and longer-running work. The component includes built-in discovery and health checks, optional authentication via either a cookie ownership challenge or kernel peer credentials on supported platforms, and an optional per-command permission policy that can restrict access by user or group. Errors and malformed input are turned into safe error responses so other clients and the server stay intact. It is ideal as a local RPC or control endpoint for daemons, command-line tools, cron jobs, and other processes on the same host.

Algorithm::Classifier::IsolationForest is a Perl implementation of Isolation Forest and Extended Isolation Forest for unsupervised anomaly detection that scores and flags outliers in multivariate numeric data. It supports classic axis-aligned trees or oblique hyperplane splits for elongated or multimodal data, offers a majority-voting aggregation mode, can learn a contamination cutoff from training data, and provides both batch and streaming (Online) variants. The module includes practical features for production use such as saving/loading models as JSON, named-feature and munger support to convert tagged input into numeric features, a packed-data wrapper for repeated fast scoring, and optional native acceleration via Inline::C and OpenMP that yields large speedups while preserving result parity with the pure-Perl implementation. Recent releases added fit_from_csv for training directly from very large CSV files without slurping them into memory and explain_samples which reports per-feature attributions (ablation and path methods) to help you understand why a point was scored as anomalous. If you need a robust, configurable anomaly detector for offline, interactive or streaming workflows that can scale with optional native acceleration and offers model persistence and explainability, this module is likely relevant.

IO::K8s provides typed Perl objects and serialization helpers for working with Kubernetes resources, letting you convert between JSON, YAML and Perl structures while ensuring the correct types that Kubernetes expects. It can load and validate YAML manifests including multi-document files, collect validation errors, construct objects programmatically, serialize to YAML or JSON, and save manifests to disk. The module supports Custom Resource Definitions by letting you write small CRD classes or by auto-generating classes from a cluster OpenAPI spec, and it can merge external resource maps such as Cilium to add third‑party CRDs and handle name collisions. IO::K8s is designed to work with Kubernetes::REST for live CRUD operations and exposes convenient methods like inflate, json_to_object and object_to_struct to move data between formats. Be aware that the library was rewritten for this major release, moving from Moose to Moo and replacing individual List classes with a unified List class, so upgrading may require code changes.

Crypt::OpenSSL::PKCS12 is a Perl wrapper around OpenSSL's PKCS#12 API that makes it easy to read, create and manipulate .p12/.pfx bundles from Perl. You can load a PKCS12 blob from a file or string and extract the end-entity certificate, CA chain and private key as PEM, verify the bundle MAC, change the bundle password or create a new PKCS12 file or raw DER string, and obtain the same human-readable info output that the openssl command produces or receive that information as a structured hash. The module supports OpenSSL 1.x and 3.x but changing passwords is not reliably supported on OpenSSL 3.x so recreating the file may be preferable, and it offers flags to suppress keys or certificates when dumping. It requires an OpenSSL installation and Perl 5.14 or later, and recent releases include important security fixes and crash bug fixes so upgrading to the latest version is recommended.

Crypt::OpenSSL::X509 is a Perl wrapper around OpenSSL's X.509 API that makes it simple to load, inspect and reformat X.509 certificates from files or in-memory data, in PEM or ASN.1 form. It exposes high-level accessors for common certificate fields such as subject, issuer, serial, validity dates, public key details and fingerprints, plus helpers to check expiry, test for self-signed certs and emit the cert back as PEM or DER. The module also parses extensions and Subject Alternative Names, returns extension and name objects you can query by OID or friendly name, and provides convenience routines for key IDs, bit strings and extended key usages; note that some extension helpers will croak on malformed DER so you should guard calls when handling untrusted input. It is actively maintained for compatibility across a wide range of OpenSSL and LibreSSL releases including OpenSSL 4.x. Recent releases include important security hardening and bug fixes addressing two CVEs and several memory and parsing issues, so updating to the latest version is strongly recommended.

Tie::Google::Sheets lets you treat a Google Sheets document like a Perl hash by mapping worksheet titles to hashes of A1 cell addresses so you can read and write cells with simple Perl syntax such as $doc{Sheet}{A1}. You create the tie with a spreadsheet id or URL and authenticate with a Google service account JSON key or a supplied OAuth bearer token, and you can create, list or delete sheets either by assigning or deleting top-level hash keys or by calling methods on tied(%doc). The module exposes only cell values, not formatting or formula metadata, and every cell access issues a separate Google Sheets API call so it is not optimized for bulk operations. Remember to share the spreadsheet with the service account email and that a spreadsheet must always retain at least one worksheet so you cannot clear the tied hash completely.

Open::API is a focused OpenAPI 3.1 toolkit that compiles a single spec at startup and gives you both a high-performance PSGI server and a spec-driven HTTP client. You hand it a hashref, JSON or YAML text, or a filename and it precompiles every parameter, header, cookie and body schema via JSON::Schema::Fast so routing and validation happen on a fast C path. Handlers are wired by operationId and receive typed, default-filled inputs with cookie parsing and decoded bodies, and you get optional response validation plus before and after hooks for authentication and response mutation. It supports nonblocking Futures on compatible servers, fails fast on malformed specs or duplicate operationIds, and the same compiled object drives Open::API::Client when Fetch is available. The module only supports OpenAPI 3.1, requires JSON::Schema::Fast, and is released as version 0.01.

File::ValueFile is a compact Perl utility module that supplies global helpers for working with ValueFile-formatted data and is intended to be used together with File::ValueFile::Simple::Reader and File::ValueFile::Simple::Writer rather than as a full reader or writer itself. It provides known() to enumerate well known tag identifiers and add_utf8_marker() to register formats or features that should be treated as UTF-8, accepting identifiers in the Data::Identifier form so the Simple reader and writer can autodetect encoding and tag formats. The module acts as a central place to manage tag and encoding behavior across the File::ValueFile tools. The recent v0.11 release added support for writing multiple tag names, accepts Data::Identifier objects for tag names, fixed comment encoding issues, and updated dependencies.

Catalyst::Plugin::Authentication is the core authentication layer for Catalyst web applications that supplies a pluggable, realm-based system to verify and manage users. It separates credential verification from user storage by pairing credential plugins with store backends into named realms, so you can authenticate against a simple in-memory hash, a DBIx::Class model, LDAP, or other sources without changing your application logic. It integrates with Catalyst sessions to persist login state and can rotate session IDs to help mitigate session-fixation attacks. Your app interacts with it through simple methods such as $c->authenticate to log users in, $c->user and $c->user_exists to inspect the current user, $c->logout to end a session, and $c->find_user and persist_user to manage stored identities. The plugin is designed to be extended by many credential and store modules and works with authorization plugins like Roles and ACL. Be aware that the API moved to a realms-based design in version 0.10 and a compatibility mode exists for older credential and store modules.

Hyperman is a high-performance PSGI web server for Perl that combines a prefork supervisor with a per-worker XS event loop to serve synchronous and asynchronous apps with very low overhead. It runs any Plack app and lets handlers return a Hyperman::Future or any Future-compatible object so you can write nonblocking request handlers while the worker pumps its own loop. Hyperman supports TLS including SNI and optional/required client certs, cleartext and ALPN HTTP/2, multiple listeners per process with built-in https redirect, and production features like graceful drain, worker respawn and zero-downtime restarts. Logging can be done with a fast C-written Combined Log Format writer or a Perl coderef for custom handling. The module exposes timer and io_ready futures plus per-worker stats and also publishes a public C ABI so other XS modules can drive the loop and create or settle futures entirely from C. Recent releases added a stable public C ABI, HTTP/1 chunked-body decoding, hardening against request smuggling, multi-listener support and a fast builtin access log, making Hyperman a good fit if you need a low-latency, high-throughput PSGI server with async primitives and tight C integration.

Amazon::API is a lightweight, generic Perl client for calling Amazon Web Services that you can use directly for simple REST-style requests or as a base class to generate full, service-specific modules from Botocore metadata with the included amazon-api tool. It focuses on giving you a DIY kit to install and call only the AWS methods you need while handling signing, content-type selection, pagination and response decoding so you can talk to most AWS services without a large SDK. The module works best when you generate stubs and shape classes from Botocore metadata so requests and responses are serialized correctly, it integrates with a small credential provider and supports debugging and different error-handling modes, and the author explicitly recommends Paws for users who want a full-featured, community-supported SDK. Recent updates in the 2.4.6 release improve parameter validation and give you global control over validation level via VALIDATE_MODE, add support for loading and unloading header-located request members, and harden serialization around blobs and timestamps so Botocore-based requests are more reliable. It is production-ready for many APIs but the author cautions that some services have unique quirks and that S3 in particular is better served by dedicated S3 modules.

String::Super is a small Perl utility for packing a set of strings into a single compact superstring that contains every input as a substring. You feed it raw 8-bit blobs with add_blob or text with add_utf8, then call compact or simply ask for result or offset which will trigger compaction automatically. The module trades off between optimality and computation cost to produce a reasonably small result rather than trying to solve the NP-hard exact problem, so it is useful for reducing duplication, packing resources, shrinking embedded data, or aiding simple compression and string-analysis tasks. It is binary safe and returns both the combined blob and the byte offsets of each original input via offset. An experimental prefix_blob option lets you pin one blob to offset zero when absolute placement matters, though that can force less efficient packing. Recent releases added the experimental prefix_blob feature and a minor spelling fix; the API is straightforward and the module dies on error to make failure handling explicit.

Amazon::Credentials is a Perl utility that locates and returns AWS credentials by walking a configurable chain of providers until it finds usable keys. It supports credentials from environment variables, container endpoints (ECS, Lambda, Fargate, EKS Pod Identity), EC2 instance profiles via IMDSv2, OIDC web‑identity tokens (EKS IRSA and GitHub Actions), and local AWS config/credentials files including credential_process and SSO. The module exposes a simple constructor with options to control search order, timeouts, caching, region and logging, plus helpers to check expiration, refresh temporary tokens, and fetch SSO role credentials or set environment variables for them. Security-conscious defaults include IMDSv2 enabled and closure-based storage of secrets so they do not appear in dumps or logs. You can avoid metadata timeouts by setting AWS_EC2_METADATA_DISABLED, lowering the timeout, or supplying an explicit search order. One limitation is that it will not automatically resolve role profiles that require assuming a role via a source profile in the credentials file, though web‑identity federation is supported. Recent 1.3.2 fixes improve web‑identity error reporting and token handling and add JWT claim decoding.

File::URIList is a compact Perl utility for reading and writing URI list files under RFC 2483 so you can parse, produce, or transform lists of URIs in a predictable way. It offers streaming reads via callbacks or bulk reads into an array, and lets you append URIs or comments back to the file, with automatic conversion of plain strings into URI objects and integration with the Data::Identifier family for optional type conversion. The reader exposes configurable policies for blank lines, extra surrounding spaces, missing schemes, and leading slashes, and you can supply a base URI to resolve relative entries which is useful when working with M3U-style files. The module defaults to strict parsing and will die on errors, and its rewind and clear operations require a seekable filehandle so be careful when mixing reads and writes. The current release also exposes a media_subtype accessor and includes dependency fixes.

XML::Sig is a Perl toolkit for creating and verifying XML Digital Signatures according to the W3C XML Signature standard. It lets you sign XML fragments or whole documents with a private key or embedded X.509 certificate and verify signatures using the public key delivered with the signature, making it useful for SAML, SOAP, and other XML-based authentication scenarios. The module supports RSA, ECDSA, optional DSA, HMAC, and x509-encoded signatures and implements common canonicalization methods and the enveloped-signature transform so signatures remain valid across equivalent XML representations. Configuration options let you supply key and certificate files or text, choose digest and signature hash algorithms, control X509 encoding, set which node ID to sign, and omit the XML declaration for fragment signing. After verification XML::Sig exposes the signer's certificate and lists of verified IDs or element nodes so you can confirm exactly which parts of the document were covered and defend against signature-wrapping attacks. The module depends on XML::LibXML, Digest::SHA and various Crypt::* libraries for the required crypto support.

XML::Hash::XS is a compact, high-performance Perl extension written in C that converts between Perl hashes and XML both ways while keeping memory use very low by streaming data instead of building a full DOM. It can emit XML to a string, a filehandle, or a callback and can parse strings, filehandles or incremental chunks through a parser, supports encoding options, pretty printing, canonical key ordering, an attribute-mode that maps hash keys to XML attributes, and filters and callbacks for extracting or handling specific nodes in large documents. The module also understands object serialization via toString, overloaded stringification, or an iternext iterator to generate large XML sets efficiently. Optional libraries such as XML::LibXML and iconv or ICU extend DOM building and charset conversion features. This module is a good fit when you need very fast, memory‑efficient hash-to-XML or XML-to-hash conversion and streaming processing of large XML.

Punk::Queue is a durable, database-backed job queue for Perl that implements its hot paths in C for speed and atomicity. Jobs are stored as rows in SQLite or PostgreSQL and are claimed and recorded by multiple worker processes so work survives crashes and restarts. It provides a rich enqueue API with priority, delay, dependencies, uniqueness keys, per-queue and per-task defaults, and a worker runtime that atomically dequeues, performs and records results or failures. Retries use randomized exponential backoff to avoid thundering herds and three layers of timeout handling protect the system while the supervisor can forcibly kill long-running children. The queue preserves a full per-job log across attempts, offers migration and schema versioning, a repair action to tidy crashed state, simple leasing and counted locks, broadcasting to workers, and admin-friendly listing and stats endpoints. Because Punk::Queue delivers at-least-once semantics tasks must be idempotent by design. This is the initial 0.01 release.

Kubernetes::REST is a Perl client that exposes a simple, high level REST interface to the Kubernetes API and returns typed IO::K8s resource objects instead of raw hashes. It implements standard CRUD operations like list, get, create, update, patch and delete plus convenient helpers such as ensure, ensure_all and ensure_only for idempotent apply and pruning, and it supports streaming operations like watch and log. The client automatically builds API paths from resource metadata, can fetch the cluster resource map from the OpenAPI spec by default, and provides utilities for schema comparison and for async wrappers such as prepare_request, build_path, process_watch_chunk and process_log_chunk. Authentication is token based and the HTTP transport is pluggable so you can use the default LWP backend, HTTP::Tiny or supply an async backend that consumes the Role::IO interface. Note that duplex operations like exec, attach and port_forward require an IO backend with call_duplex and are not supported by the default sync backends. The module also supports multiple patch strategies, handles common race conditions during ensure, and is well suited for scripts, CLIs or integrating Kubernetes access into Perl services.

Container::Buildah is a Perl wrapper around the buildah command that lets you script multi-stage OCI/Docker-compatible container builds from Perl, running each stage as a callback inside the container's user namespace so you get the flexibility of code rather than a static Dockerfile. You define stages with init_config, provide a function for each stage, and Container::Buildah hands a Stage object into those functions with convenience methods that mirror buildah subcommands, which makes it easy to pipeline artifacts from build stages into runtime images and to perform rootless builds. The module is aimed at developers who want programmatic, scriptable control over container construction using buildah instead of hand-edited containerfiles, and it requires a Linux kernel of version 2.8 or newer. Recent releases focused on documentation and examples and added a configurable option around image history handling along with tests for kernel compatibility.

Container::Builder is a Perl toolkit for assembling OCI-style container archives that you can import with podman or Docker by composing layers from Debian .deb packages and local files. It gives simple, Dockerfile-like operations to add Debian packages or package files, extract files from packages, copy directories, add files or string content, create users and groups, set environment variables, working directory and entrypoint, and then produce a single tar archive when you call build. You can point it at a nearby Debian mirror, pick an OS version, enable caching of downloaded .debs and choose whether to gzip-compress layer tars to trade speed for disk space. The module is aimed at crafting minimal, reproducible Debian-based images for development, testing and build experiments rather than as a full production image builder, and the author notes it is still early in development. Recent releases added the ability to embed a container name so podman load can auto-tag the image and fixed digest/diffID handling to produce correct layer and config checksums.

Mojolicious::Plugin::BarefootJS plugs the BarefootJS server runtime into Mojolicious so you can call a per-request BarefootJS instance from your controllers and templates via the bf helper, render compiled BarefootJS templates as Mojolicious templates, and drive server-side rendering using the BarefootJS::Backend::Mojo adapter. It keeps integration simple and framework-native while the separate BarefootJS::Backend::Xslate offers the same runtime for non-Mojolicious or PSGI hosts. A recent improvement changed how the build manifest is loaded so it is read lazily and cached by mtime/size, which prevents boot-time race issues and allows manifest updates to be picked up without restarting the server.

BarefootJS::Backend::Xslate provides a simple Text::Xslate (Kolon) rendering backend for the BarefootJS runtime, letting you render .tx templates on the server without any specific web framework so it works equally well in PSGI/Plack apps or plain scripts. It is designed to be used with the @barefootjs/xslate compile-time adapter which emits Kolon templates that call the runtime as a bf object, so helpers become bf methods and the default Xslate instance needs no special function map. The backend builds Xslate for HTML auto-escaping, supports marking raw HTML when a helper intentionally emits markup, and implements the runtime-facing operations you need: rendering named templates with bf bound, JSON encoding, and materializing values. You can construct it from a prebuilt Text::Xslate object or by passing template paths and Xslate options, making server-side rendering of Kolon templates straightforward and safe for BarefootJS projects.