crosspack 0.5.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 446cc8ee80c8c72227611451283314f75a8c9a276e915cecd416c72269e10d7a
-  data.tar.gz: f6186516867c2dbb74871991d33b9eb3e24ab79c627ad32dd169bf8b0be78611
+  metadata.gz: 369c6df533b4a7e576fb1bfe4af308d0e422082934a533995355eb1bec6f8854
+  data.tar.gz: 65eca41ff0574b5460dffcfe9a2e33f36936ddff9184a4ed2908df0290f711e8
 SHA512:
-  metadata.gz: 1208559fef0f7a26b62b375d4ca90578fd52668cb30862f4ba9245e3402f6b4f0e512ef4b0029eea5072328c2818e21f9d3f5ebd584edfd286b34abc9a977fa3
-  data.tar.gz: 6902bf1a81aa6ecaecc8fead2fed2886e80f948957e8bead59be6cba6ec9710d22457bed4e7ffb9e8b793e956baf764aab0a0c7ff584eb7ed13c81f23f4e3add
+  metadata.gz: 7449ad323b7beb15a046ced0dfb3e47caf437d3844f660af93d4da19e3d2fd74cc64ed62f3e531589e6079c49309ee82ec7c1959f3cdef093cc517a9e67cc2d7
+  data.tar.gz: e58bf61ce945544bc8ba0dd96c41760ffa8637cdb934bef375c18c3d70ef3aa465369a8122455008964cd608eabf066e79a6dfe60fa5f5bca87051d42b5e5bc0

data/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.2] - 2026-09-13
+
+### Added
+- Colored CLI output via the new `colorize` runtime dependency: success
+  messages green, errors red, validation warnings yellow (the `ok`/`MISSING`
+  statuses in the deps report included). Colors apply only to a TTY and
+  respect `NO_COLOR`, so piped and logged output stays plain.
+- The gem now ships `logo.png` in its files.
+
+## [0.6.1] - 2026-09-13
+
+### Fixed
+- `crosspack deps` no longer dumps a Ruby backtrace when the (detected or
+  given) target has no matrix entry — it aborts with the plain message, now
+  with an actionable hint (pass a declared target or extend artifacts.to).
+- `crosspack --version` (bare, also `-v`) prints the gem version instead of
+  demanding an argument; `--version X` keeps overriding the build/pack
+  version.
+
+[0.6.2]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.6.2
+[0.6.1]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.6.1
+
+## [0.6.0] - 2026-09-13
+
+### Added
+- Host target default: `crosspack deps` / `build` / `pack` invoked without a
+  target run for the current host — `macos`, `windows-11.0` or the distro
+  family + version from `/etc/os-release` (unknown distro ids fall back to
+  the first known `ID_LIKE` token; unrecognizable hosts ask for an explicit
+  target).
+- Per-target payload names: `package.payload` entries may now be written as a
+  mapping `common key -> {target selector -> real file name}` instead of a
+  flat list. The key is the common name (used verbatim on every target
+  unless overridden); selectors are an exact target (`windows-11.0`), a
+  family (`windows`) or `"*"` (exact target wins, then family, then `"*"`).
+  An entry with a selector map applies only to targets it covers, so one
+  payload lists `app`/`app.exe`, `.so` libraries and Windows DLLs together —
+  each target resolves to the files its build actually produced. The flat
+  list form remains valid (same name everywhere). `executables` keeps naming
+  common keys and resolves per target at pack time.
+
+[0.6.0]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.6.0
+
 ## [0.5.1] - 2026-09-13
 
 ### Fixed

data/README.md

@@ -22,6 +22,15 @@ crosspack build ubuntu-24.04
 crosspack pack ubuntu-24.04
 ```
 
+The target may be omitted — the stage commands then run for the current
+host: `macos`, `windows-11.0` or the distro family + version from
+`/etc/os-release` (unknown ids fall back to the first known `ID_LIKE`
+token):
+
+```
+crosspack deps && crosspack build && crosspack pack
+```
+
 ## crosspack.yml — one file, three sections
 
 The top level carries the shared facts — `name` (required once) and the
@@ -91,11 +100,27 @@ package:
   lib_dir: lib/myapp          # optional, default lib/<name>
 
   payload:                    # files from sources -> <prefix>/<lib_dir>/
-    - myapp
+    - myapp                   # flat form: the same name on every target
     - helper
     - model.onnx
 
-  executables: [myapp, helper]     # chmod 755, must be in payload
+  # Mapping form: per-target file names. The key is the common name (and the
+  # default file name); selectors are an exact target (windows-11.0), a
+  # family (windows), an os (linux — every distro family) or "*" — exact
+  # target wins, then family, then os, then "*". An entry with selectors
+  # applies only to targets it covers, so .so libraries and Windows DLLs can
+  # share one payload:
+  #
+  # payload:
+  #   myapp:
+  #     "*": myapp
+  #     windows: myapp.exe
+  #   libonnxruntime.so.1:
+  #     linux: libonnxruntime.so.1
+  #   onnxruntime.dll:
+  #     windows: onnxruntime.dll
+
+  executables: [myapp, helper]     # common keys; chmod 755, resolved per target
 
   links:                     # symlinks relative to prefix
     bin/myapp: ../lib/myapp/myapp

data/exe/crosspack

@@ -12,25 +12,48 @@ rescue LoadError
 end
 
 def abort_with(message)
-  warn message
+  warn Crosspack::Colors.red(message)
   exit 1
 end
 
+# Validate reports line by line: valid → green, invalid → red, warnings → yellow.
+def colorized_report(text)
+  text.lines.map do |line|
+    chomped = line.chomp
+    colored =
+      if chomped.include?('is invalid')
+        Crosspack::Colors.red(chomped)
+      elsif chomped.include?('is valid')
+        Crosspack::Colors.green(chomped)
+      elsif chomped.strip.start_with?('⚠')
+        Crosspack::Colors.yellow(chomped)
+      end
+    colored ? "#{colored}\n" : line
+  end.join
+end
+
 options = { file: Crosspack::Config::DEFAULT_PATH, arch: 'amd64',
             format: nil, version: nil, root: Dir.pwd, output_base: nil,
             check_only: false, no_deps: false, all: false }
+
+# `crosspack --version` (also bare -v) prints the gem version like any other
+# CLI; with a value the flag stays the build/pack version override.
+if ARGV.size == 1 && %w[--version -v].include?(ARGV.first)
+  puts "crosspack #{Crosspack::VERSION}"
+  exit
+end
 parser = OptionParser.new do |opts|
   opts.banner = "crosspack #{Crosspack::VERSION} — staged pipeline: deps → build → pack\n" \
                 "Usage: crosspack <command> [options]\n" \
-                "Stages:   deps <target> [--check]      verify/install build deps for the target's host\n" \
-                "          build <target>|--all          compile the target's matrix entry into builds/\n" \
-                "          pack <target> [--version X]   package builds/<target> (version from the build stamp)\n" \
+                "Stages:   deps [<target>] [--check]      verify/install build deps (default: this host)\n" \
+                "          build [<target>]|--all          compile into builds/ (default: this host)\n" \
+                "          pack [<target>] [--version X]   package builds/<target> (default: this host; version from the build stamp)\n" \
                 'Commands: validate, resolve, matrix, version, targets'
 
   opts.on('-f', '--file PATH', 'path to crosspack.yml (default: ./crosspack.yml)') { |v| options[:file] = v }
   opts.on('--arch ARCH', 'architecture: amd64/x86_64, arm64/aarch64 (default: amd64)') { |v| options[:arch] = v }
   opts.on('--format FORMAT', 'output format for resolve: deb, rpm, pkgbuild (default: derived from the target)') { |v| options[:format] = v.to_sym }
-  opts.on('--version VERSION', 'override the version for build/pack') { |v| options[:version] = v }
+  opts.on('--version VERSION', 'override the version for build/pack; a bare `crosspack --version` prints the gem version') { |v| options[:version] = v }
   opts.on('--root PATH', 'project root for relative paths (default: .)') { |v| options[:root] = v }
   opts.on('--output-base DIR', 'output directory (build stage: the manifest output, default builds; pack: default ./crosspacks)') { |v| options[:output_base] = v }
   opts.on('--check', 'with `deps`: only report presence, never install (exit 1 if missing)') { options[:check_only] = true }
@@ -79,6 +102,19 @@ def entry_for_target!(manifest, target, host_os, host_arch)
   end
 
   entry
+rescue Crossbuild::Error => e
+  abort_with e.message
+end
+
+# Stage commands (deps/build/pack) run for the current host when no target
+# is given: macos, windows-11.0 or the distro from /etc/os-release.
+def host_target!(command)
+  raw = Crosspack::Target.host_string
+  abort_with "Could not detect this host's target — pass one explicitly: crosspack #{command} <target> " \
+             '(families: ubuntu-24.04, debian-12, fedora-41, arch, macos, windows-11.0)' if raw.nil?
+
+  puts "→ no target given; using this host's target: #{raw}"
+  raw
 end
 
 case command
@@ -86,10 +122,10 @@ when 'validate'
   deps_manifest = config.deps_manifest
   pkg = config.package_manifest
   build_manifest = config.build_manifest
-  puts config.error_report
-  puts deps_manifest.error_report
-  puts pkg.error_report
-  puts build_manifest.error_report
+  puts colorized_report(config.error_report)
+  puts colorized_report(deps_manifest.error_report)
+  puts colorized_report(pkg.error_report)
+  puts colorized_report(build_manifest.error_report)
   ok = config.valid? && deps_manifest.valid? && pkg.valid? && build_manifest.valid?
   exit(ok ? 0 : 1)
 when 'matrix'
@@ -131,12 +167,12 @@ when 'version'
     abort_with e.message
   end
 when 'deps'
-  abort_with 'Specify a target: crosspack deps debian-12 (see crosspack --help)' unless positional
+  target_str = positional || host_target!('deps')
   build_manifest = config.build_manifest
   abort_with 'the build: section is invalid — run: crosspack validate' unless build_manifest.valid?
-  entry_for_target!(build_manifest, positional, Crossbuild::Platform.os, Crossbuild::Platform.arch)
-  installer = Crossbuild::DepInstaller.new(build_manifest, root: options[:root])
   begin
+    entry_for_target!(build_manifest, target_str, Crossbuild::Platform.os, Crossbuild::Platform.arch)
+    installer = Crossbuild::DepInstaller.new(build_manifest, root: options[:root])
     if options[:check_only]
       installer.check_all
       puts "deps on this host:\n#{installer.report}"
@@ -146,15 +182,14 @@ when 'deps'
   rescue Crossbuild::Error => e
     abort_with e.message
   end
-  puts "deps ready:\n#{installer.report}"
+  puts Crosspack::Colors.green("deps ready:\n#{installer.report}")
 when 'build'
   build_manifest = config.build_manifest
   abort_with 'the build: section is invalid — run: crosspack validate' unless build_manifest.valid?
   if options[:all]
     target = nil
   else
-    abort_with 'Specify a target: crosspack build ubuntu-24.04 (or --all for every host-buildable entry)' unless positional
-    target = positional
+    target = positional || host_target!('build')
   end
   begin
     result = Crossbuild::Builder.new(build_manifest, root: options[:root],
@@ -163,12 +198,12 @@ when 'build'
   rescue Crossbuild::Error, Crosspack::InvalidManifestError => e
     abort_with e.message
   end
-  puts "\n📦 #{result.entries.size} entr#{result.entries.size == 1 ? 'y' : 'ies'} built, version #{result.version}"
+  puts Crosspack::Colors.green("\n📦 #{result.entries.size} entr#{result.entries.size == 1 ? 'y' : 'ies'} built, version #{result.version}")
   puts 'Pack with: crosspack pack <target>'
 when 'pack'
-  abort_with 'Specify a target: crosspack pack debian-12' unless positional
+  target_str = positional || host_target!('pack')
   begin
-    target = Crosspack::Target.parse(positional, arch: options[:arch])
+    target = Crosspack::Target.parse(target_str, arch: options[:arch])
     path = Crosspack.pack(
       config: config,
       target: target,
@@ -177,11 +212,11 @@ when 'pack'
       output_base: options[:output_base] || 'crosspacks'
     )
   rescue Crosspack::Target::Error => e
-    abort_with "Invalid target #{positional.inspect}: #{e.message}"
+    abort_with "Invalid target #{target_str.inspect}: #{e.message}"
   rescue Crosspack::InvalidManifestError, Crosspack::ResolveError, Crosspack::BuildError => e
     abort_with e.message
   end
-  puts "📦 #{path}"
+  puts Crosspack::Colors.green("📦 #{path}")
 when 'targets'
   # What can actually be packed: builds tree + resolvable deps per target.
   pkg = config.package_manifest

data/lib/crossbuild/build_manifest.rb

@@ -143,7 +143,8 @@ module Crossbuild
       if matches.empty?
         raise Error,
               "no matrix entry distributes to target #{raw.inspect}; " \
-              "declared targets: #{declared.join(', ')}"
+              "declared targets: #{declared.join(', ')}. Pass one of them explicitly, " \
+              "or add #{raw.inspect} to the entry's artifacts.to in crosspack.yml"
       end
       if matches.size > 1
         raise Error,

data/lib/crossbuild/dep_installer.rb

@@ -53,8 +53,10 @@ module Crossbuild
       return '  (no deps declared)' if @manifest.deps.empty?
 
       (@statuses || check_all).map do |s|
+        state = format('%-8s', s.installed ? 'ok' : 'MISSING')
+        state = Crosspack::Colors.public_send(s.installed ? :green : :red, state)
         format('  %-20s %-8s %-8s %s',
-               s.dep, s.installed ? 'ok' : 'MISSING', s.selector, s.command)
+               s.dep, state, s.selector, s.command)
       end.join("\n")
     end
 

data/lib/crosspack/colors.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+module Crosspack
+  # CLI message coloring (green = success, red = errors, yellow = warnings),
+  # powered by the colorize gem. Colors are turned off automatically when the
+  # output is not a TTY or NO_COLOR is set, so piped and logged output stays
+  # clean.
+  module Colors
+    class << self
+      attr_writer :enabled
+
+      def enabled?
+        return @enabled unless @enabled.nil?
+
+        ENV['NO_COLOR'].nil? && ($stdout.tty? || $stderr.tty?)
+      end
+
+      def red(text)
+        enabled? ? text.to_s.colorize(:red) : text
+      end
+
+      def green(text)
+        enabled? ? text.to_s.colorize(:green) : text
+      end
+
+      def yellow(text)
+        enabled? ? text.to_s.colorize(:yellow) : text
+      end
+    end
+  end
+end

data/lib/crosspack/package_manifest.rb

@@ -5,10 +5,25 @@ module Crosspack
   # WHAT and HOW to pack — payload, executables, symlinks, desktop entry,
   # icon. Compilation is not crosspack's business; artifacts are picked from
   # `sources` as-is.
+  #
+  # Payload entries may carry per-target file names: the key is the common
+  # name (used verbatim everywhere unless a selector map says otherwise),
+  # and each selector (exact target "windows-11.0", family "windows" or "*")
+  # maps to the real file name that target's build produces. An entry with a
+  # selector map applies only to targets it covers — a Windows build dir has
+  # no .so libraries and vice versa.
   class PackageManifest
     REQUIRED = %w[maintainer description sources prefix payload].freeze
     OPTIONAL = %w[name summary license section lib_dir executables links desktop icon].freeze
 
+    # Payload selectors may name an os in addition to a family: every distro
+    # family packs a linux target, so "linux:" covers deb/rpm/PKGBUILD
+    # without enumerating them (macos and windows are their own families).
+    OS_BY_FAMILY = Hash.new('linux').merge(macos: 'macos', windows: 'windows').freeze
+
+    # One payload file: its common key plus the per-target name overrides.
+    PayloadFile = Struct.new(:key, :names, keyword_init: true)
+
     attr_reader :path, :data, :errors, :warnings
 
     def initialize(path, raw)
@@ -17,6 +32,7 @@ module Crosspack
       @raw = raw
       @errors = []
       @warnings = []
+      @payload_entries = []
       validate
     end
 
@@ -72,14 +88,40 @@ module Crosspack
       @data['prefix']
     end
 
+    # Common keys of the payload entries (the executables list and links
+    # reference these); use payload_for(target) for the real file names.
     def payload
-      Array(@data['payload'])
+      @payload_entries.map(&:key)
+    end
+
+    # Real file names the given target's package carries. Every entry
+    # resolves through its selector map — exact target string, then family,
+    # then "*"; entries without a map use their key on every target; entries
+    # whose selectors do not cover the target are skipped.
+    def payload_for(target)
+      @payload_entries.filter_map { |entry| resolve_entry(entry, target) }
     end
 
     def executables
       Array(@data['executables'])
     end
 
+    # Executable file names for the target. The executables list names
+    # common payload keys; they resolve to the target's real file names.
+    def executables_for(target)
+      executables.map do |key|
+        entry = @payload_entries.find { |e| e.key == key }
+        resolved = entry && resolve_entry(entry, target)
+        if resolved.nil?
+          raise InvalidManifestError,
+                "executables: #{key.inspect} resolves to no file for target #{target} — " \
+                'its payload entry has no name for that target'
+        end
+
+        resolved
+      end
+    end
+
     def summary
       @data['summary'] || description.lines.map(&:chomp).reject(&:empty?).first || name
     end
@@ -153,17 +195,91 @@ module Crosspack
       value = @data['payload']
       return if value.nil? # already reported as missing
 
-      unless value.is_a?(Array) && !value.empty?
-        @errors << Issue.new('payload', 'must be a non-empty list of artifact files from sources')
-        return
+      @payload_entries =
+        if value.is_a?(Array)
+          validate_payload_list(value)
+        elsif value.is_a?(Hash)
+          validate_payload_map(value)
+        else
+          @errors << Issue.new('payload', 'must be a non-empty list of artifact files or a mapping: key -> {target -> real file name}')
+          []
+        end
+      return unless @payload_entries.empty?
+
+      @errors << Issue.new('payload', 'must name at least one artifact file from sources')
+    end
+
+    # Legacy/simple form: a flat list — every name applies to every target.
+    def validate_payload_list(value)
+      value.each_with_index.with_object([]) do |(item, i), entries|
+        if item.is_a?(String) && !item.strip.empty? && !item.start_with?('/')
+          entries << PayloadFile.new(key: item, names: {})
+        else
+          @errors << Issue.new("payload[#{i}]", 'file name must be a non-empty relative string (no leading "/")')
+        end
       end
-      value.each_with_index do |item, i|
-        next if item.is_a?(String) && !item.strip.empty? && !item.start_with?('/')
+    end
 
-        @errors << Issue.new("payload[#{i}]", 'file name must be a non-empty relative string (no leading "/")')
+    # Mapping form: common key -> null (key everywhere) or a selector map
+    # (exact target / family / "*") of real file names per target.
+    def validate_payload_map(value)
+      value.each_with_object([]) do |(key, names), entries|
+        if !key.is_a?(String) || key.strip.empty? || key.start_with?('/')
+          @errors << Issue.new("payload.#{key.inspect}", 'must be a non-empty relative file name (no leading "/")')
+          next
+        end
+        if names.nil? || names == {}
+          entries << PayloadFile.new(key: key, names: {})
+          next
+        end
+        unless names.is_a?(Hash)
+          @errors << Issue.new("payload.#{key}", 'must be null or a mapping of target selector -> real file name')
+          next
+        end
+
+        resolved = {}
+        entry_valid = true
+        names.each do |selector, name|
+          unless valid_selector?(selector)
+            @errors << Issue.new("payload.#{key}.#{selector}",
+                                 "unknown target selector (allowed: \"*\", an os (linux) or a family " \
+                                 "(#{Target::FAMILIES.join(', ')}), optionally with a version, e.g. windows-11.0)")
+            entry_valid = false
+            next
+          end
+          if !name.is_a?(String) || name.strip.empty? || name.start_with?('/')
+            @errors << Issue.new("payload.#{key}.#{selector}", 'file name must be a non-empty relative string (no leading "/")')
+            entry_valid = false
+            next
+          end
+          resolved[selector] = name
+        end
+        entries << PayloadFile.new(key: key, names: resolved) if entry_valid
       end
     end
 
+    def valid_selector?(selector)
+      return true if selector == '*'
+      return true if selector == 'linux' # the one os selector (macos/windows are families)
+
+      Target.parse(selector.to_s)
+      true
+    rescue Target::Error
+      false
+    end
+
+    # Exact target string ("windows-11.0") wins over the family ("windows"),
+    # then the os ("linux"), then "*"; an entry without a map carries its
+    # key on every target.
+    def resolve_entry(entry, target)
+      return entry.key if entry.names.empty?
+
+      entry.names[target.to_s] ||
+        entry.names[target.family.to_s] ||
+        entry.names[OS_BY_FAMILY[target.family]] ||
+        entry.names['*']
+    end
+
     def validate_executables
       value = @data['executables']
       return if value.nil?

data/lib/crosspack/packer.rb

@@ -96,7 +96,7 @@ module Crosspack
       end
 
       lib_dst = File.join(@pkg.prefix, @pkg.lib_dir)
-      files = @pkg.payload.to_h { |n| [File.join(src_dir, n), File.join(lib_dst, n)] }
+      files = @pkg.payload_for(@target).to_h { |n| [File.join(src_dir, n), File.join(lib_dst, n)] }
 
       if @pkg.icon
         icon_src = File.expand_path(@pkg.icon, @root)
@@ -110,7 +110,7 @@ module Crosspack
       end
 
       symlinks = @pkg.links.to_h { |link, target| [File.join(@pkg.prefix, link), target] }
-      executables = @pkg.executables.map { |exe| File.join(lib_dst, exe) }
+      executables = @pkg.executables_for(@target).map { |exe| File.join(lib_dst, exe) }
 
       { files: files, symlinks: symlinks, executables: executables,
         src_dir: src_dir, lib_dst: lib_dst }
@@ -192,7 +192,7 @@ module Crosspack
         depends: resolved_depends(:pkgbuild),
         arch: [@target.package_arch(:pkgbuild)],
         # PKGBUILD sources are archive-relative names, not local paths.
-        files: @pkg.payload.to_h { |n| [n, File.join(@pkg_data[:lib_dst], n)] },
+        files: @pkg.payload_for(@target).to_h { |n| [n, File.join(@pkg_data[:lib_dst], n)] },
         symlinks: @pkg_data[:symlinks],
         executables: @pkg_data[:executables],
         source: ["#{@pkg.name}-#{version}.tar.gz"],
@@ -213,7 +213,7 @@ module Crosspack
     def pack_windows
       output = File.join(@target.output_dir(@output_base, :winget),
                          "#{@pkg.name}-#{Builders::Wix.msi_version(@version)}.msi")
-      files = @pkg.payload.to_h { |n| [File.join(@pkg_data[:src_dir], n), n] }
+      files = @pkg.payload_for(@target).to_h { |n| [File.join(@pkg_data[:src_dir], n), n] }
       Builders::Wix.build(
         name: @pkg.name,
         version: @version,
@@ -228,13 +228,13 @@ module Crosspack
     # macOS: .app bundle staging; DMG itself requires a Mac (hdiutil).
     def pack_macos
       output_dir = @target.output_dir(@output_base, :cask)
-      files = @pkg.payload.to_h { |n| [File.join(@pkg_data[:src_dir], n), n] }
+      files = @pkg.payload_for(@target).to_h { |n| [File.join(@pkg_data[:src_dir], n), n] }
       Builders::AppDir.build(
         name: @pkg.name,
         version: @version,
         summary: @pkg.summary,
         files: files,
-        executables: @pkg.executables,
+        executables: @pkg.executables_for(@target),
         output: output_dir
       )
     end

data/lib/crosspack/target.rb

@@ -55,6 +55,45 @@ module Crosspack
       new(family_sym, version, norm_arch)
     end
 
+    # The target of the machine crosspack runs on, for stage commands invoked
+    # without an explicit target: "macos", "windows-11.0" or the distro
+    # family + version from the os-release file ("ubuntu-24.04",
+    # "debian-12", "fedora-41", "arch"). Unknown distro ids fall back to the
+    # first ID_LIKE token that names a family. Returns nil when the host is
+    # not recognizable — the CLI then asks for an explicit target.
+    # Windows defaults to the 11.0 target vocabulary (10 is EOL); pass a
+    # target explicitly when packing for another release.
+    def self.host_string(ruby_platform: RUBY_PLATFORM, release_path: '/etc/os-release')
+      case ruby_platform
+      when /darwin/ then 'macos'
+      when /mingw|mswin|cygwin/i then 'windows-11.0'
+      when /linux/
+        facts = host_os_release(release_path)
+        family = ([facts['ID']] + facts['ID_LIKE'].to_s.split)
+                   .filter_map { |id| id.to_s.to_sym if id }
+                   .find { |f| FAMILIES.include?(f) }
+        return nil if family.nil?
+
+        version = facts['VERSION_ID'].to_s
+        return family.to_s if VERSIONLESS_FAMILIES.include?(family) ||
+                               OPTIONAL_VERSION_FAMILIES.include?(family)
+        return nil if version.empty? # e.g. Debian sid: no pin-able version
+
+        "#{family}-#{version}"
+      end
+    end
+
+    def self.host_os_release(path)
+      File.read(path).each_line.with_object({}) do |line, facts|
+        key, value = line.split('=', 2)
+        next if value.nil?
+
+        facts[key.strip] = value.strip.delete_prefix('"').delete_suffix('"')
+      end
+    rescue Errno::ENOENT
+      {}
+    end
+
     def initialize(family, version = nil, arch = :x86_64)
       @family = family.to_sym
       @version = version && version.to_s

data/lib/crosspack/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crosspack
-  VERSION = '0.5.1'
+  VERSION = '0.6.2'
 end

data/lib/crosspack.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'crosspack/version'
+require_relative 'crosspack/colors'
 require_relative 'crosspack/target'
 require_relative 'crosspack/manifest'
 require_relative 'crosspack/package_manifest'

metadata

@@ -1,15 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: crosspack
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Oleg Orlov
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
-dependencies: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: 'One command, one config file, one target vocabulary: crosspack deps
   <target> verifies and installs the build host dependencies, crosspack build <target>
   runs the crosspack.yml build matrix entry and fans artifacts into builds/, crosspack
@@ -43,6 +56,7 @@ files:
 - lib/crosspack/builders/rpm.rb
 - lib/crosspack/builders/wix.rb
 - lib/crosspack/builds.rb
+- lib/crosspack/colors.rb
 - lib/crosspack/config.rb
 - lib/crosspack/manifest.rb
 - lib/crosspack/matrix.rb
@@ -51,13 +65,13 @@ files:
 - lib/crosspack/resolver.rb
 - lib/crosspack/target.rb
 - lib/crosspack/version.rb
+- logo.png
 homepage: https://github.com/OrelSokolov/crosspack
 licenses:
 - Nonstandard
 metadata:
   source_code_uri: https://github.com/OrelSokolov/crosspack
   changelog_uri: https://github.com/OrelSokolov/crosspack/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -72,8 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: 'One config (crosspack.yml), staged pipeline: deps → build → pack native
   packages (deb/rpm/PKGBUILD/winget/cask)'