Skip to content
CAI
Software that uses CAICheck a score

sbt/sbt-native-packager

56.7

Adequate · 14 November 2026

8.7k

lines of production code

Scala

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Classpath and Launcher JAR packaging plugins

Two new SBT plugins are introduced to support Java application packaging: ClasspathJarPlugin and LauncherJarPlugin. ClasspathJarPlugin adds a new artifact (classifier 'classpath') that generates a JAR with a manifest specifying the runtime classpath, while LauncherJarPlugin adds a 'launcher' classifier JAR that embeds both the main class and classpath in its manifest. Both plugins integrate with the existing JavaAppPackaging to ensure these JARs are included in the Universal distribution and that the generated bash and batch scripts are configured to use them correctly.

src/main/scala/com/typesafe/sbt/packager/jar · high confidence

Add Play Framework RPM integration test project

A new test project has been added to the integration tests to validate packaging a Play Framework application as an RPM package. This includes a Vagrant environment provisioned via Ansible to set up the JDK, sbt, and build tools, along with a Play application configured with sbt-native-packager to generate an RPM (including epoch support). The entry also includes the Ansible test playbook that builds the RPM, installs it, verifies the service health, and cleans up. Also in this area: Play Framework controller and view updated to modern DI patterns.

integration-tests-ansible/test-project-play-rpm · high confidence

Add Windows test project with SBT build configuration

A new test project for Windows environments has been introduced, establishing the build infrastructure with SBT version 1.2.6 and configuring the sbt-native-packager plugin. The project includes the sbt-scalafmt plugin (version 1.10) to handle code formatting on compile, and provides a sample Scala application (ExampleApp) that demonstrates concurrent execution using a fixed thread pool.

test-project-windows · high confidence

Add simple test project for sbt-native-packager

A new test project named 'test-project-simple' has been added to the repository. It is configured with sbt version 1.2.6 and includes the sbt-scalafmt plugin for code formatting. The project defines a simple Scala application (ExampleApp) that prints memory usage and arguments, and includes a template file for default configuration, serving as a basic example or test case for the sbt-native-packager plugin.

test-project-simple · high confidence

Added Docker test project scaffold

A new test project for Docker functionality has been introduced, providing a concrete example for building and testing Docker images. This includes a docker-compose configuration defining a 'fooservice' using the 'docker-test:latest' image, an SBT build setup (version 1.5.4) that references the sbt-native-packager and includes the Spotify Docker Client library (version 3.5.13), and a basic Scala application entry point.

test-project-docker · high confidence

Added command line JAVA\_OPTS support for AshScriptPlugin

The AshScriptPlugin now supports passing command-line JAVA\_OPTS, allowing users to configure JVM options when running scripts. This is demonstrated by the new MainApp test file which prints system properties and arguments, verifying that environment and command-line settings are correctly propagated.

src/sbt-test/ash/command-line-settings/src · high confidence

Added etc-default template for Debian override tests

A new template file has been added to the Debian override test suite to support the configuration of application defaults via /etc/default. This change provides the necessary template structure for system services to source these default values, enabling users to override default settings through standard Debian configuration paths.

src/sbt-test/debian/override-etc-default/src · medium confidence

Initial Windows MSI packaging support via WiX Toolset

This change introduces the WindowsPlugin, enabling the generation of Windows Installer (MSI) packages for sbt projects. It adds a dedicated 'windows' configuration that maps universal package files to WiX features, automatically generating the necessary WiX XML configuration and invoking the WiX Toolset (candle and light) to produce the final .msi artifact. Users can now build Windows installers by enabling the plugin, with sensible defaults for product IDs, upgrade IDs, and environment variable updates.

src/main/scala/com/typesafe/sbt/packager/windows · high confidence

Initial support for JDK Packager via Ant tasks

Introduces the JDKPackagerPlugin, enabling the generation of native installers (such as .exe, .dmg, .pkg, .deb, and .rpm) by leveraging the Oracle JDK 8 \ant-javafx.jar\ Ant tasks. This change adds configuration keys for specifying the installer type, JVM arguments, application arguments, file associations, and custom icons, along with helper logic to locate the required Ant library across different operating systems and Java installation layouts.

src/main/scala/com/typesafe/sbt/packager/jdkpackager · high confidence

Introduce JlinkPlugin for creating optimized Java runtime images

Adds the JlinkPlugin, an AutoPlugin that enables building custom Java runtime images using the standard jlink utility. This allows users to create smaller, optimized runtimes by including only the necessary Java modules and dependencies, with automatic dependency resolution via jdeps and support for ignoring missing dependencies.

repository · high confidence

The Linux packaging module now provides a dedicated plugin that manages file ownership, daemon user configuration, and symlink generation for Debian and RPM packages. Users can configure specific daemon users, groups, UIDs, GIDs, shells, and home directories, which are applied to installed files and service scripts. The plugin also automatically generates symlinks for binaries and configuration directories, and exposes settings for script replacements, log locations, and file descriptor limits to tailor the installed service behavior.

src/main/scala/com/typesafe/sbt/packager/linux · high confidence

Introduce native Debian packaging implementation alongside JDeb

The Debian plugin now includes a native packaging implementation (DebianNativePackaging) that uses the system's dpkg toolchain (dpkg-deb, dpkg-genchanges, dpkg-sig) to build .deb packages, in addition to the existing Java-based JDeb implementation. This new path generates native Debian control files and changelogs, supports package signing via dpkg-sig, and allows lintian validation. Users can enable this via the DebianNativePackaging plugin to leverage native tools instead of the JVM-based jdeb library.

src/main/scala/com/typesafe/sbt/packager/debian · high confidence

Introduces GraalVM native-image build configuration keys

Adds the GraalVMNativeImageKeys trait to define sbt settings for GraalVM native image packaging, including graalVMNativeImageOptions for passing arguments to the native-image tool, graalVMNativeImageGraalVersion to specify the GraalVM version for container-based builds, and graalVMNativeImageCommand to define the executable command used for building.

src/main/scala/com/typesafe/sbt/packager/graalvmnativeimage · high confidence

Introduction of JlinkPlugin configuration keys

The JlinkPlugin now exposes a set of configurable settings and tasks to control the JVM image creation process. Users can now specify the modules to include via \jlinkModules\, pass custom arguments to the jlink utility through \jlinkOptions\, and define the module path using \jlinkModulePath\. Additionally, a new hook \jlinkIgnoreMissingDependency\ allows users to mask specific missing package dependency issues that would otherwise cause the build to fail, providing finer control over the bundling process.

src/main/scala/com/typesafe/sbt/packager/archetypes/jlink · high confidence

Introduction of the SbtNativePackager AutoPlugin

The sbt-native-packager is now available as an AutoPlugin (\SbtNativePackager\), allowing users to enable packaging capabilities simply by adding \enablePlugins(SbtNativePackager)\ to their build configuration. This top-level plugin aggregates settings and tasks from various packaging archetypes (Universal, Linux, Debian, Rpm, Windows, Docker) and provides a unified \autoImport\ namespace for all native packager keys. It establishes default values for common settings like \maintainer\, \packageDescription\, and \executableScriptName\, and includes deprecated helper methods (\java\_application\, \java\_server\) to guide users toward the new plugin-based enabling style.

src/main/scala/com/typesafe/sbt · high confidence

Native packager core utilities and staging infrastructure

This change introduces the foundational infrastructure for the native packager plugin, including file permission handling, hashing, and staging logic. It adds FileUtil to manage POSIX file permissions (with Windows fallback) and support for SOURCE\_DATE\_EPOCH to enable reproducible builds by normalizing file timestamps. Hashing utilities for SHA-1, SHA-512, and MD5 are added for artifact integrity checks. The Stager component now handles file synchronization with caching and ensures executable permissions are correctly set on staged scripts. Additionally, a comprehensive set of keys (Keys.scala) and settings helpers (SettingsHelper.scala) are defined to configure package metadata, script names, maintainer scripts, and publishing behaviors for various target platforms.

src/main/scala/com/typesafe/sbt/packager · high confidence

New /etc/default configuration templates for SystemV and Systemd packaging

The packaging archetypes now include new template files (application.ini-template, etc-default-template, and etc-default-systemd-template) that allow users to easily configure environment variables, JVM options, and PID file paths via /etc/default files. This change enables more flexible configuration of application settings at deployment time, particularly for SystemV and Systemd service managers, without requiring modifications to the startup scripts themselves.

src/main/resources/com/typesafe/sbt/packager/archetypes · high confidence

New SystemV init script templates for Debian and RPM packages

The SystemV packaging archetype now includes dedicated init script templates for both Debian and RPM distributions. The new Debian template utilizes standard LSB headers and start-stop-daemon for service management, while the RPM template integrates with Red Hat's init.d functions library. These templates provide users with robust, standardized service control (start, stop, restart, status) and support for configuration via environment files, ensuring consistent service behavior across different Linux package formats.

src/main/resources/com/typesafe/sbt/packager/archetypes/systemloader/systemv · high confidence

New package validation framework with standard checks

This change introduces a new validation system for package formats, adding a \validatePackage\ task that users can invoke (e.g., \sbt Universal/packageBin/validatePackage\) to check their configuration. It includes built-in validators to ensure the package is not empty, that all mapped files exist, that a maintainer is specified (with optional warning mode), and that RPM epochs are non-negative. This provides immediate feedback on common packaging misconfigurations before distribution.

src/main/scala/com/typesafe/sbt/packager/validation · high confidence

New structured documentation for project archetypes

The documentation has been reorganized into a new 'Archetypes' section, introducing a cheatsheet for path configurations and JVM options, and dedicated guides for the Java Application, Java Server, Jlink, and Systemloaders plugins. This structure clarifies how to customize start scripts, manage daemon users, and configure service loaders for different deployment scenarios.

src/sphinx · high confidence

New test project for JDK packager integration

Added a new test project (\test-project-jdkpackager\) that demonstrates packaging Scala applications using the JDK's \javapackager\ tool. The project includes a JavaFX-based example application (\ExampleApp\) that displays system properties, and configures JVM options via a \jvmopts\ file to verify argument processing during the packaging process.

test-project-jdkpackager · high confidence

Support for multiple main classes in application packaging

The packaging plugin now generates separate launch scripts for each main class defined in the project (e.g., \main-app\ and \second-app\) when no single main class is explicitly configured. If a main class is explicitly set via \Compile / mainClass\, the default script retains the project name while additional scripts for other main classes are still generated. This behavior is verified for both Bash and Windows environments.

src/sbt-test/bash/multiple-apps, src/sbt-test/windows/multiple-apps · high confidence

Support for overriding RPM scriptlets in packaging

Users can now provide custom RPM installation scriptlets (pre, post, preun, postun) to override the default packaging behavior. This change introduces the ability to define specific shell scripts for these lifecycle stages, allowing for more granular control over the installation and removal processes of RPM packages generated by the tool.

src/sbt-test/rpm/scriptlets-override-rpm/src · high confidence

Systemd service template and loader functions added

The systemd packaging archetype now includes a new service unit template (start-template) and a shell script for loader functions (loader-functions). The service template defines the unit structure, including support for configurable retry timeouts, success exit statuses, stop timeouts, and file descriptor limits. The loader functions provide scripts to add, start, stop, and restart the systemd service, handling configuration prefixing and enabling the service on the system.

src/main/resources/com/typesafe/sbt/packager/archetypes/systemloader/systemd · high confidence

Universal packaging plugin introduces native zip support and macOS DMG generation

The universal packager now supports creating macOS DMG files via the new \packageOsxDmg\ task and offers a \useNativeZip\ setting to generate ZIP archives using the system's native zip utility, which better preserves executable permissions compared to the previous Java-based implementation. The plugin also defines \stage\ and \dist\ tasks for the \Universal\, \UniversalDocs\, and \UniversalSrc\ configurations, allowing users to build distribution packages that include these specific artifact types.

src/main/scala/com/typesafe/sbt/packager/universal · high confidence

Removals

Removal of legacy Debian packaging plugin

The legacy Debian packaging plugin (DebianPlugin, Keys, and metadata.scala) has been removed from the codebase. This eliminates the ability to generate .deb packages, create control files, and run lintian checks via the previous implementation, effectively removing Debian-specific packaging capabilities from this module.

src/main/scala/com/typesafe/packager/debian · high confidence

Removal of legacy Linux packaging keys and mapping classes

The \Keys.scala\ file, which defined the \maintainer\ and \linuxPackageMappings\ settings, and the \LinuxPackageMapping.scala\ file, which contained the \LinuxFileMetaData\ and \LinuxPackageMapping\ case classes, have been deleted from the \src/main/scala/com/typesafe/packager/linux\ directory. This change removes the specific Scala definitions for Linux package file mappings and metadata configuration from this location, likely as part of a cleanup or consolidation into a common plugin structure.

src/main/scala/com/typesafe/packager/linux · high confidence

Behavioural changes

Debian packaging scripts now support custom daemon user and group IDs

The Debian package maintainer scripts (postinst, postrm, preinst, prerm) have been refactored to support explicit configuration of the daemon user and group. The postinst script now creates the daemon user and group using specific UID and GID values provided via template variables, and ensures the home directory is created. The postrm script handles cleanup by deleting the user and group only during a purge operation, while preinst and prerm remain minimal. This allows users to packagers to control the identity of the service account more precisely.

src/main/resources/com/typesafe/sbt/packager/debian · high confidence

Disable Jekyll processing for site content

A .nojekyll file has been added to the site root to prevent Jekyll from processing the site's content. This ensures that static assets and files starting with an underscore are preserved as-is rather than being treated as Jekyll-specific templates or data files.

src/site · high confidence

Docker plugin refactored with new permission strategies and layer grouping

The Docker plugin has been restructured to introduce configurable file permission strategies (None, Run, MultiStage, CopyChown) and granular chmod types, allowing users to control how file modes are handled in the resulting image. It also implements a new layer grouping mechanism that separates dependencies, libraries, and configuration into distinct layers to improve Docker cache efficiency. Additionally, the plugin now supports multi-stage builds, BuildKit detection, and exposes UDP ports alongside TCP, while updating the default base image to eclipse-temurin:25.

src/main/scala/com/typesafe/sbt/packager/docker · high confidence

RPM packaging plugin refactored into AutoPlugin with new configuration keys

The RPM packaging functionality has been restructured into a new \RpmPlugin\ AutoPlugin that extends \LinuxPlugin\, introducing a dedicated \Rpm\ configuration and a comprehensive set of new \SettingKey\ and \TaskKey\ definitions in \Keys.scala\ for metadata, dependencies, scriptlets, and build options. The implementation in \RpmHelper.scala\ now handles staging, spec file generation, and \rpmbuild\ execution, while the plugin settings unify maintainer scripts and apply defaults for RPM-specific behaviors like \brpJavaRepackJars\ and \sourceDateEpoch\ support.

src/main/scala/com/typesafe/sbt/packager/rpm · high confidence

Refactor start script generation into modular plugins and add Ash shell support

The script generation logic in this package has been restructured into distinct, modular plugins: BashStartScriptPlugin, BatStartScriptPlugin, and a new AshScriptPlugin for generating scripts compatible with the lightweight ash shell (e.g., BusyBox). A shared CommonStartScriptGenerator trait and ScriptUtils handle the core logic for creating start scripts and forwarders, while ApplicationIniGenerator manages the generation of application.ini configuration files. This change introduces new sbt keys (e.g., bashScriptTemplateLocation, batScriptConfigLocation) and improves support for multiple main classes by generating specific scripts or forwarders for each discovered entry point.

src/main/scala/com/typesafe/sbt/packager/archetypes/scripts · high confidence

Refactor system loader plugins into AutoPlugins with new configuration keys

The system loader plugins (Systemd, SystemV, Upstart) have been extracted into their own AutoPlugins, introducing a new \ServerLoader\ enumeration and a set of shared configuration keys in \SystemloaderKeys\. This change adds \serviceAutostart\ to control whether the service starts after installation, \systemdSuccessExitStatus\ for Systemd, and \systemdIsServiceFileConfig\ to mark the Systemd unit file as a configuration file rather than a regular script. It also standardizes the start script location for Systemd to \/lib/systemd/system\ on Debian and \/usr/lib/systemd/system\ on RPM, and updates the Systemd plugin to use \TimeoutStopSec\ for the kill timeout.

src/main/scala/com/typesafe/sbt/packager/archetypes/systemloader · high confidence

Refactored Java application packaging into modular archetypes

The Java application packaging logic has been reorganized into distinct, modular components to improve maintainability and separation of concerns. The core settings and tasks for general Java applications are now defined in \JavaAppKeys\ and \JavaAppKeys2\, while the \JavaAppPackaging\ plugin handles the universal distribution structure, including classpath ordering and dependency artifact resolution. A new \JavaServerAppPackaging\ archetype specifically targets server applications, introducing settings for daemon user/group ownership, configurable log file locations (\daemonStdoutLogFile\), and integration with the \/etc/default\ configuration file. Supporting infrastructure includes \JavaServerBashScript\ for loading loader-specific init scripts (SystemD, SystemV, Upstart), \MaintainerScriptHelper\ for easier customization of Debian/RPM maintainer scripts, and \TemplateWriter\ for consistent script generation from templates.

src/main/scala/com/typesafe/sbt/packager/archetypes · high confidence

Refactored RPM packaging scripts with dedicated pre/post-install templates

The RPM packaging templates for the Java server archetype have been refactored to use dedicated \pre-template\ and \postun-template\ scriptlets. The new \pre-template\ handles user and group creation during initial installation and manages the \PACKAGE\_PREFIX\ configuration in \/etc/sysconfig/\, while the \postun-template\ ensures system users and groups are cleaned up only during a full uninstall (not during upgrades). This change centralizes control logic via \control-functions\ and improves the reliability of package lifecycle operations.

_src/main/resources/com/typesafe/sbt/packager/archetypes/java\server · high confidence

Replace deprecated scala.App with standard Main object

The Spotify client test application now uses a standard Main object with a main method instead of extending scala.App, avoiding deprecated Scala language features and ensuring more predictable initialization behavior.

src/sbt-test/docker/spotify-client/src · high confidence

Support for explicit UID/GID and home directory creation in Linux packaging

The Linux packaging scripts now support specifying explicit user and group IDs (UID/GID) when creating system users and groups, allowing for more deterministic container or system environments. Additionally, the user creation process now automatically creates the user's home directory (defaulting to /var/lib/$user), ensuring that applications running as these users have a valid home directory available.

src/main/resources/com/typesafe/sbt/packager/linux · high confidence

Documentation references in configuration files, templates, and source code comments have been updated to use HTTPS URLs instead of HTTP. This affects the Play Framework application secret documentation, sbt-native-packager cheatsheets and system loader guides, and various Stack Overflow references included in JavaServer, Docker, JDK Packager, and ZipHelper modules. Also in this area: Add Play Framework RPM integration test project.

integration-tests-ansible/test-project-play-rpm/conf · high confidence

Update test application to avoid deprecated scala.App

The test application in the docker layer-groups test suite has been refactored from using the deprecated scala.App trait to a standard Main object with a main method. This ensures the test code remains compatible with current Scala standards and avoids deprecation warnings.

src/sbt-test/docker/test-layer-groups/src · high confidence

Updated Scala 2.12 and Scala 3 compatibility layers for sbt 2.x support

The Scala 2.12 and Scala 3 source directories now include updated compatibility shims (Compat, MappingsHelper, PluginCompat) to support sbt 2.x. In Scala 2.12, the Compat object provides deprecated aliases for internal sbt types (e.g., IvyActions, BuildDependencies) and an implicit conversion for file caching, while MappingsHelper and PluginCompat adapt helper methods and settings to the new sbt API. In Scala 3, Compat is effectively empty, MappingsHelper returns initialized settings using FileConverter, and PluginCompat adapts artifact naming and ivyModule settings to the sbt 2.x structure.

src/main/scala-2.12 · high confidence

Updated backward compatibility filters for sbt 1.3.15

This release adds a new set of MiMa (Migration Manager) backward-compatibility excludes for version 1.3.15. These filters suppress warnings for API changes in the sbt-packager project, including new settings for Docker build environment variables, GraalVM native image configuration, and forwarder script templates for start scripts, as well as structural changes to Windows, Debian, and RPM packaging plugins.

src/main/mima-filters · high confidence

Updated shell and batch start scripts with improved argument handling and Cygwin support

The generated start scripts for Linux/macOS (bash and ash) and Windows (bat) have been updated to improve reliability and compatibility. Key changes include using \exec\ in forwarder scripts to ensure correct process signaling, adding support for the \JAVA\_OPTS\ environment variable in ash templates, and fixing argument parsing to correctly handle spaces and special characters. The bash and ash templates now include robust \realpath\ implementations to resolve symlinks correctly on macOS and handle Cygwin path conversions, while the Windows batch scripts have been enhanced to support the \-jvm-debug\ flag and better configuration file loading.

src/main/resources/com/typesafe/sbt/packager/archetypes/scripts · high confidence

Upstart service configuration now supports advanced lifecycle and resource settings

The Upstart system loader has been updated to allow users to configure service restart behavior, file descriptor limits, and environment variable handling. The generated Upstart job now includes a configurable kill timeout, a respawn policy with retry limits and intervals, and a setting for the maximum number of open file descriptors. Additionally, the service startup script now automatically loads an external environment configuration file and exports its variables to the daemon process.

src/main/resources/com/typesafe/sbt/packager/archetypes/systemloader/upstart · high confidence

Fixes

Disable jar repacking in RPM builds

The RPM packaging process now includes a configuration that disables the automatic repacking of JAR files (by setting \_\_jar\_repack to nil). This change addresses issues where repacking was incorrectly negated or causing build problems, resulting in faster and more reliable RPM builds for users.

src/main/resources/com/typesafe/sbt/packager/rpm · high confidence

Test coverage

Add minimal jlink integration test; Add sbt test for Java Home variable expansion; Add sbt test for Windows memory settings; Add sbt-test for app settings and native packaging; Add scripted test for Docker image removal via clean task; Add scripted test for Docker image user creation; Add scripted test for RPM setarch packaging; Add scripted test for basic Docker image building; Add scripted tests for JDK 8, 11, 17, 21, and 25 support; Added JDK packager test scenarios for image, mappings, and minimal packaging; Added Windows packaging test for the Java app archetype; Added Windows sbt-test cases for app-home variable expansion and dynamic app environment names; Added Windows-specific test for custom main class packaging; Added automated test for RPM changelog and brpJavaRepackJars configuration; Added example source for Docker command override tests; Added integration tests for Ash, Bash, Debian, and RPM packaging plugins; Added integration tests for Docker build command override; Added launcher-jar sbt test case; Added regression test for RPM scriptlet override functionality; Added regression test for rpm scriptlet overrides; Added regression tests for RPM scriptlet configuration and version checking; Added sbt test cases for JVM memory settings and simple application packaging; Added sbt test for launcher JAR packaging; Added sbt test for memory settings in native packaging; Added sbt-test cases for ash and bash script generation; Added sbt-test cases for custom ASH script templates; Added scripted test for Docker latest tag updates; Added scripted test for Docker multiple tags support; Added scripted test for Docker plugin with multiple main classes; Added scripted test for JDKPackager package mappings; Added scripted test for RPM artifact path generation; Added scripted test for RPM config-no-replace behavior; Added scripted test for RPM loader function override; Added scripted test for RPM package generation; Added scripted test for Spotify Client Docker image; Added scripted test for custom WiX source support; Added scripted test for debian genChanges task; Added scripted test for debian package mapping and control script; Added scripted test for debian packageName configuration; Added scripted test for executableScriptName setting; Added scripted test for jdeb directory mappings; Added scripted test for universal package naming; Added scripted tests for Debian Provides and Conflicts sections; Added scripted tests for Debian native packaging; Added scripted tests for Debian package generation; Added scripted tests for Debian package structure and autostart configuration; Added scripted tests for Docker alias and build options; Added scripted tests for Docker entrypoint plugin; Added scripted tests for Docker environment variable handling; Added scripted tests for Docker file permission strategies; Added scripted tests for Docker image generation and execution; Added scripted tests for Docker label handling; Added scripted tests for Docker staging functionality; Added scripted tests for Docker volume export behavior; Added scripted tests for GraalVM native image generation; Added scripted tests for RPM init script overrides; Added scripted tests for RPM packaging with and without Java repackaging; Added scripted tests for debian packaging and sbt 2 caching; Added scripted tests for debian packaging template and directory mappings; Added scripted tests for executableScriptName setting; Added scripted tests for systemd Debian packaging and autostart configuration; Added scripted tests for sysvinit stop timeout packaging; Added scripted tests for universal packaging formats; Added scripted tests for universal publish and Maven publishing; Added scripted tests for zip packaging without top-level directory; Added test asset for multiproject classifier support; Added test case for classpath-jar functionality; Added test case for launching JARs from paths containing spaces; Added test case for overriding bash and bat templates; Added test cases for Scala 3 top-level main methods; Added test cases for packageName support in Docker and Universal plugins; Added test cases for the executableScriptName setting; Added test coverage for JLinkPlugin scenarios; Added test coverage for RPM path override behavior; Added test coverage for RPM path override scenarios; Added test coverage for packaging utilities and plugins; Added test coverage for universal distribution packaging; Added test fixture files for Docker layer group testing; Added test fixtures for Debian package mapping helpers; Added test fixtures for RPM start script template overrides; Added test fixtures for generic Debian package mapping; Added test fixtures for overriding Debian control scripts; Added test fixtures for systemd integration on Debian and RPM; Added test fixtures for sysvinit RPM generation; Added test for Cygwin Java app archetype; Added test for Debian daemon package with custom group ID; Added test for Debian package file permissions; Added test for Debian package user shell configuration; Added test for JVM options in application.ini; Added test for RPM symlink handling in spec files; Added test for UDP port exposure in Docker builds; Added test for UDP-only port exposure; Added test for Windows batch script generation; Added test for classifier handling in multiproject builds; Added test for classpath-jar plugin; Added test for custom main class in staged distribution; Added test for daemon user control script generation; Added test for daemon user home directory creation in Debian packaging; Added test for executableScriptName setting; Added test for handling missing dependencies in JLinkPlugin; Added test for jdeb dependency packaging; Added test for jdeb script replacements; Added test for overriding Debian control files; Added test for systemd loader function override behavior; Added test resources for jdeb directory mapping validation; Added test suite for java-app-archetype; Added test suite for universal mapping helpers; Added test utility for validating Windows batch exit codes; Added tests for Debian package user/group ID configuration; Added tests for Docker command override functionality; Added tests for Docker layer grouping configuration; Added tests for absolute paths in classpath; Added tests for command-line settings in AshScriptPlugin; Added tests for executableScriptName setting; Added tests for systemd Debian packaging and service autostart configuration; Added tests to verify correct start script template selection for systemd, SystemV, and Upstart; Added validation test for empty distribution prevention; Test for multi-stage intermediate image removal; Test verifies staging directory cleanup of removed configuration files; Updated staging-custom-main test sources.

Housekeeping

Repository initialization and tooling configuration

The repository has been initialized with standard project configuration files, including a .gitignore to exclude IDE and build artifacts, a .scalafmt.conf to enforce code formatting (version 3.11.5), and a .git-blame-ignore-revs file to ignore formatting commits. Documentation and legal files such as README.md, CHANGELOG.md, LICENSE (Apache 2.0), NOTICE, CODE\_OF\_CONDUCT.md, and CONTRIBUTING.md have been added, along with an AppVeyor CI configuration (appveyor.yml) for Windows builds.

(repo-wide) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 59 → 57 (-2.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 72 → 70 (-2.6)
  • Architecture 90 → 100 (+10.1)
  • Maturity 57 → 58 (+1.3)
  • Readiness 68 → 66 (-1.3)
  • Security 50 → 45 (-5.1)
  • Performance 100 → 100 (+0.0)

Resolved (3)

  • No ADRs found
  • Off-boarding risk: anonymized user #1
  • Projects may be oversized for their cohesion

New (8)

  • Edited copy of a member (13 corresponding lines) (src/main/scala/com/typesafe/sbt/packager/universal/Archives.scala)
  • Edited copy of a member (15 corresponding lines) (src/main/scala/com/typesafe/sbt/packager/docker/DockerPlugin.scala)
  • Edited copy of a member (19 corresponding lines) (src/main/scala/com/typesafe/sbt/packager/archetypes/systemloader/SystemVPlugin.scala)
  • Edited copy of a member (22 corresponding lines) (src/main/scala/com/typesafe/sbt/packager/debian/DebianMetadata.scala)
  • Edited copy of a member (36 corresponding lines) (src/main/scala/com/typesafe/sbt/packager/archetypes/scripts/BashStartScriptPlugin.scala)
  • Edited copy of a member (6 corresponding lines) (src/main/scala-3/com/typesafe/sbt/packager/MappingsHelper.scala)
  • No ADRs found (test-project-windows/build.sbt)
  • Off-boarding risk: anonymized user #1

Changes since last survey

  • 10 commits — 9 feature/other, 1 fixes

By area

  • (repo) — 5 commits
  • .github/workflows — 2 commits
  • (root) — 1 commit
  • integration-tests-ansible/test-project-play-rpm — 1 commit
  • test-project-jdkpackager/build.sbt — 1 commit

Notable commits

  • fix: Fix build error. Avoid ubuntu-latest
  • change: Merge pull request #1848 from scala-steward/update/io-1.13.6
  • change: Merge pull request #1849 from scala-steward/update/sbt-1.13.1
  • change: Merge pull request #1851 from scala-steward/update/typesafe-1.4.10
  • change: Merge pull request #1852 from sbt/jdk-version
  • change: Merge pull request #1853 from sbt/ubuntu-24
  • change: Update Zulu JDK version
  • change: Update io to 1.13.6
  • change: Update sbt, scripted-plugin to 1.13.1
  • change: Update typesafe:config to 1.4.10

Architecture

  • Unchanged — 0 containers · 2 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

sbt/sbt-native-packager was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit d6db40f5573f7bb88f9007db5a20228ec83f56bf — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.