crosspack 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 369c6df533b4a7e576fb1bfe4af308d0e422082934a533995355eb1bec6f8854
-  data.tar.gz: 65eca41ff0574b5460dffcfe9a2e33f36936ddff9184a4ed2908df0290f711e8
+  metadata.gz: 8d03bbc2ce62c3f8cc511df1f4e9ade332adc838a361e2730154c4d9b94403a3
+  data.tar.gz: 8b3785216051ef0e2c926e9feb4a61d8473286fb3ba1a6b91d4ac19cf0969e88
 SHA512:
-  metadata.gz: 7449ad323b7beb15a046ced0dfb3e47caf437d3844f660af93d4da19e3d2fd74cc64ed62f3e531589e6079c49309ee82ec7c1959f3cdef093cc517a9e67cc2d7
-  data.tar.gz: e58bf61ce945544bc8ba0dd96c41760ffa8637cdb934bef375c18c3d70ef3aa465369a8122455008964cd608eabf066e79a6dfe60fa5f5bca87051d42b5e5bc0
+  metadata.gz: 5372d580eb8e5730c13f1fffcd08c626e272ae436dc8f0d53a9a504e398f750d25948e29e8741c138044b3a2981f2082aa73e1ca418eaa0f399988ce56cf3d94
+  data.tar.gz: 63de5f8eafe2856831605c1e667c3d2ed32a65b29c405eb8ebf854c7792616e3fa2b7370ba963cd8d78e7aa9a02edec9ed14458a61e9d4f204772856abfba6f9

data/CHANGELOG.md

@@ -5,6 +5,28 @@ 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.7.0] - 2026-09-13
+
+### Added
+- Host-only commands: `crosspack run` builds for the current host (the same
+  stage `crosspack build <host target>` runs) and then launches the main
+  binary straight from `builds/` — the first `package.executables` entry,
+  not the package. Arguments after `--` are passed to the app
+  (`crosspack run -- --dev`); the app's exit code is propagated.
+- `crosspack install` launches this host's package with its system
+  installer: the newest package in `crosspacks/<host target>/` goes to
+  `xdg-open` (deb/rpm), `msiexec /i` (MSI) or `open` (macOS dmg/.app);
+  for arch crosspack generates only a PKGBUILD, so it points at
+  `makepkg -si`.
+- crosspack.yml `run:` / `install:` sections: per-host launch-command
+  overrides using the same host selectors as `build.deps` (distro id,
+  ID_LIKE, os, `"*"`), with the `{{path}}` placeholder (the built binary
+  for run, the package file for install) plus the usual build facts.
+  Default without a `run:` section: execute the binary directly (a macOS
+  `.app` bundle is `open`ed).
+
+[0.7.0]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.7.0
+
 ## [0.6.2] - 2026-09-13
 
 ### Added

data/README.md

@@ -31,14 +31,15 @@ token):
 crosspack deps && crosspack build && crosspack pack
 ```
 
-## crosspack.yml — one file, three sections
+## crosspack.yml — one file, three sections + two host hooks
 
 The top level carries the shared facts — `name` (required once) and the
 optional `version` scheme — and three sections: `build:` (what and where to
 build), `package:` (what and how to pack) and `deps:` (runtime dependencies
-resolved to concrete packages per distro). The shared name/version feed the
-build section, the name feeds the package section; each section keeps its
-own schema.
+resolved to concrete packages per distro). Two optional hooks — `run:` and
+`install:` — override the host-only launch commands. The shared name/version
+feed the build section, the name feeds the package section; each section
+keeps its own schema.
 
 ```yaml
 name: myapp
@@ -142,6 +143,15 @@ deps:
       fedora: { "*": [webkit2gtk4.1] }
       macos: system      # OS component
       windows: system    # preinstalled (WebView2)
+
+# host-only launch hooks (optional): same host selectors as build.deps
+run:                       # `crosspack run`: how to launch the built binary
+  hosts:
+    darwin: open build/bin/MyApp.app     # .app bundles must be opened, not exec'd
+
+install:                   # `crosspack install`: how to launch this host's package
+  hosts:
+    ubuntu: sudo apt-get install -y "{{path}}"
 ```
 
 Placeholders `{{version}}`, `{{name}}`, `{{platform}}`, `{{os}}`, `{{arch}}`
@@ -192,6 +202,10 @@ crosspack deps <target> [--check]        # verify/install build deps (--check: r
 crosspack build <target>|--all [--no-deps] [--version X]
 crosspack pack <target> [--version X]    # version defaults to the build stamp
 
+# host-only: this machine, no target argument
+crosspack run [-- --dev]                 # build for this host, then launch the main binary
+crosspack install                        # launch this host's package with its installer
+
 # inspection
 crosspack validate                       # crosspack.yml: top level + all sections
 crosspack resolve <target>               # Depends line for the target
@@ -212,6 +226,32 @@ crosspacks/fedora/41/x86_64/myapp-2026.08.31-1234.x86_64.rpm   (needs rpmbuild)
 crosspacks/arch/x86_64/PKGBUILD
 ```
 
+### Host-only commands: run and install
+
+`run` and `install` apply to the current host only — the build target *is*
+the run target, so they take no target argument. `crosspack run` runs the
+build stage for this host (same as `crosspack build <host target>`), then
+launches the first `package.executables` binary straight from `builds/` —
+the binary, not the package. Everything after `--` goes to the app:
+
+```
+crosspack run -- --dev
+```
+
+`crosspack install` takes the newest package packed for this host in
+`crosspacks/` and hands it to the system installer. Defaults: `xdg-open`
+for deb/rpm (opens GNOME Software/installer), `msiexec /i` for the MSI,
+`open` for a macOS dmg/.app; for arch crosspack only generates a PKGBUILD,
+so it points you at `makepkg -si` instead.
+
+Both are per-system by nature, so each accepts a `hosts:` override with the
+same selectors as `build.deps` (distro id, `ID_LIKE`, os, `"*"` — first
+match wins). Commands support the `{{path}}` placeholder (the binary in
+`builds/` for run, the package file for install) plus the usual
+`{{name}}`/`{{version}}`/`{{os}}`/`{{arch}}` facts; quote values that start
+with `{{` (YAML flow indicators). Without a `run:` section the binary is
+executed directly, except a macOS `.app` bundle which is `open`ed.
+
 ## Library
 
 ```ruby

data/exe/crosspack

@@ -48,6 +48,8 @@ parser = OptionParser.new do |opts|
                 "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" \
+                "Host:     run [-- <app args>]            build for this host, then launch the main binary\n" \
+                "          install                         launch this host's package with its installer\n" \
                 'Commands: validate, resolve, matrix, version, targets'
 
   opts.on('-f', '--file PATH', 'path to crosspack.yml (default: ./crosspack.yml)') { |v| options[:file] = v }
@@ -126,7 +128,11 @@ when 'validate'
   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?
+  [config.run_manifest, config.install_manifest].each do |m|
+    puts colorized_report(m.error_report) if m.present?
+  end
+  ok = config.valid? && deps_manifest.valid? && pkg.valid? && build_manifest.valid? &&
+       config.run_manifest.valid? && config.install_manifest.valid?
   exit(ok ? 0 : 1)
 when 'matrix'
   deps_manifest = config.deps_manifest
@@ -217,6 +223,32 @@ when 'pack'
     abort_with e.message
   end
   puts Crosspack::Colors.green("📦 #{path}")
+when 'run', 'install'
+  # Host-only commands: no target argument; anything after `--` goes to the
+  # launched process (crosspack run -- --dev).
+  if positional
+    abort_with "crosspack #{command} works only for the current host — no target argument " \
+               "(other targets make no sense here)"
+  end
+  args = ARGV.dup
+  args.shift if args.first == '--'
+  begin
+    status =
+      if command == 'run'
+        Crosspack::Launcher.run(
+          config, root: options[:root], args: args,
+          output_base: options[:output_base], version: options[:version], deps: !options[:no_deps]
+        )
+      else
+        Crosspack::Launcher.install(
+          config, root: options[:root], args: args,
+          output_base: options[:output_base] || 'crosspacks'
+        )
+      end
+  rescue Crosspack::InvalidManifestError, Crosspack::BuildError, Crossbuild::Error => e
+    abort_with e.message
+  end
+  exit(status) unless status.zero?
 when 'targets'
   # What can actually be packed: builds tree + resolvable deps per target.
   pkg = config.package_manifest
@@ -224,5 +256,5 @@ when 'targets'
   root = sources ? File.expand_path(sources, options[:root]) : File.join(options[:root], 'builds')
   puts Crosspack::Builds.report(root)
 else
-  abort_with "Unknown command #{command.inspect}. Available: deps, build, pack, validate, resolve, matrix, version, targets"
+  abort_with "Unknown command #{command.inspect}. Available: deps, build, pack, run, install, validate, resolve, matrix, version, targets"
 end

data/lib/crosspack/command_manifest.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Crosspack
+  # Parses and validates the optional run:/install: sections of crosspack.yml.
+  # Both map host selectors (the same vocabulary as the deps: rules of the
+  # build: section: distro id from os-release, ID_LIKE token, os name, "*")
+  # to a shell command with {{path}} and the usual build facts:
+  #
+  #   run:
+  #     hosts:
+  #       darwin: open build/bin/MyApp.app
+  #       "*": "{{path}} --dev"
+  #
+  # A section is optional; when absent the host-only default applies
+  # (see Launcher).
+  class CommandManifest
+    SECTION_KEYS = %w[hosts].freeze
+    # A host selector: "*" or a distro id / ID_LIKE token / os name —
+    # the same vocabulary as the deps: rules of the build: section.
+    SELECTOR_RE = /\A(\*|[a-z0-9][a-z0-9+._-]*)\z/i.freeze
+
+    attr_reader :path, :section, :errors, :warnings
+
+    def initialize(path, raw, section)
+      @path = path
+      @section = section
+      @raw = raw
+      @hosts = {}
+      @errors = []
+      @warnings = []
+      validate
+    end
+
+    def present?
+      !@raw.nil?
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    # The command for the given host selectors (see Crossbuild::Platform
+    # .selectors), first match wins; nil when nothing applies.
+    def command_for(selectors)
+      selectors.each { |s| return @hosts[s] if @hosts.key?(s) }
+      nil
+    end
+
+    def error_report
+      return "#{@path}: the #{@section}: section is absent — defaults apply" unless present?
+
+      lines = ["#{@path}: the #{@section}: section is #{@errors.empty? ? 'valid' : "invalid (#{@errors.size} errors)"}:"]
+      @errors.each { |e| lines << "  ✗ #{e}" }
+      @warnings.each { |w| lines << "  ⚠ #{w}" }
+      lines.join("\n")
+    end
+
+    def validate!
+      return self if valid?
+
+      raise InvalidManifestError, error_report
+    end
+
+    private
+
+    def validate
+      return unless present?
+
+      unless @raw.is_a?(Hash) && !@raw.empty?
+        @errors << Issue.new("#{@section}", "must be a non-empty mapping with the key: hosts; expected:\n" \
+                                            "    #{@section}:\n" \
+                                            "      hosts:\n" \
+                                            "        ubuntu: #{@section == 'install' ? 'xdg-open {{path}}' : '{{path}} --dev'}")
+        return
+      end
+      check_unknown_keys
+
+      hosts = @raw['hosts']
+      return unless hosts
+
+      unless hosts.is_a?(Hash) && !hosts.empty?
+        @errors << Issue.new("#{@section}.hosts", 'must be a non-empty mapping of host selector -> shell command')
+        return
+      end
+
+      hosts.each do |selector, command|
+        validate_rule(selector.to_s, command)
+      end
+    end
+
+    def check_unknown_keys
+      @raw.keys.map(&:to_s).each do |key|
+        next if SECTION_KEYS.include?(key)
+
+        @errors << Issue.new("#{@section}.#{key}", "unknown key; allowed: #{SECTION_KEYS.join(', ')}")
+      end
+    end
+
+    def validate_rule(selector, command)
+      path = "#{@section}.hosts.#{selector}"
+      unless selector =~ SELECTOR_RE
+        @errors << Issue.new(path, "invalid host selector (expected a distro id, os name or \"*\")")
+        return
+      end
+      unless command.is_a?(String) && !command.strip.empty?
+        @errors << Issue.new(path, 'must be a non-empty shell command')
+      end
+      @hosts[selector] = command if command.is_a?(String) && !command.strip.empty?
+    end
+  end
+end

data/lib/crosspack/config.rb

@@ -15,7 +15,7 @@ module Crosspack
   # happens per section, not per file.
   class Config
     DEFAULT_PATH = 'crosspack.yml'
-    TOP_LEVEL_KEYS = %w[name version build package deps].freeze
+    TOP_LEVEL_KEYS = %w[name version build package deps run install].freeze
     NAME_RE = /\A[a-z0-9][a-z0-9+._-]*\z/i.freeze
 
     attr_reader :path, :errors, :warnings
@@ -81,6 +81,15 @@ module Crosspack
       @deps_manifest ||= Manifest.new(@path, deps_section)
     end
 
+    # The optional run:/install: sections (host-only launch commands).
+    def run_manifest
+      @run_manifest ||= CommandManifest.new(@path, @raw['run'], 'run')
+    end
+
+    def install_manifest
+      @install_manifest ||= CommandManifest.new(@path, @raw['install'], 'install')
+    end
+
     private
 
     def validate
@@ -124,7 +133,7 @@ module Crosspack
     end
 
     def check_section_types
-      %w[build package deps].each do |key|
+      %w[build package deps run install].each do |key|
         next unless @raw.key?(key) && !@raw[key].is_a?(Hash)
 
         @errors << Issue.new(key, 'must be a mapping')

data/lib/crosspack/launcher.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Crosspack
+  # Host-only launch commands: `crosspack run` (build the host target, then
+  # launch the application's main binary) and `crosspack install` (launch the
+  # package packed for this host). Both resolve the current host target, so
+  # they take no target argument and are meaningless on any other system.
+  #
+  # Commands may be overridden per host in crosspack.yml (run:/install:
+  # sections, selectors like the deps: rules of build:); placeholders:
+  # {{path}} plus the usual facts ({{name}}, {{version}}, {{os}}, {{arch}}).
+  # Defaults when nothing is configured:
+  #   run:     darwin + .app bundle -> `open {{path}}`, otherwise {{path}}
+  #   install: deb/rpm -> xdg-open, msi -> msiexec /i, dmg/.app -> open
+  class Launcher
+    class Error < BuildError; end
+
+    # Builds the host target first (the same stage `crosspack build` runs),
+    # then launches the first package.executables binary from builds/.
+    # Returns the launched process's exit code.
+    def self.run(config, root: Dir.pwd, args: [], output_base: nil, version: nil,
+                 deps: true, host_string: nil, host_os: Crossbuild::Platform.os,
+                 host_arch: Crossbuild::Platform.arch, selectors: Crossbuild::Platform.selectors)
+      config = Config.coerce(config, root: root)
+      target = host_target('run', host_string, host_arch)
+      pkg = validated_package(config)
+      build_manifest = config.build_manifest
+      build_manifest.validate!
+
+      Crossbuild::Builder.new(build_manifest, root: root, output_base: output_base,
+                                            version: version, deps: deps,
+                                            host_os: host_os, host_arch: host_arch)
+                         .run(target: target.to_s)
+
+      exe = pkg.executables_for(target).first
+      if exe.nil?
+        raise Error,
+              'run: the package: section does not name the binary to launch — ' \
+              "add executables: [#{pkg.name}] to it (the first entry is what `crosspack run` launches)"
+      end
+
+      path = File.join(File.expand_path(target.output_dir(pkg.sources, target.format), root), exe)
+      unless File.exist?(path)
+        raise Error,
+              "run: expected the built binary at #{path}, but it is not there — " \
+              'does the build step really produce it? Check package.executables against the build output'
+      end
+
+      command = config.run_manifest.command_for(selectors) || default_run_command(path, host_os)
+      execute(command, path: path, pkg: pkg, target: target, root: root, args: args)
+    end
+
+    # Finds the package packed for this host in crosspacks/ and launches it
+    # with the system installer. Returns the launched process's exit code.
+    def self.install(config, root: Dir.pwd, args: [], output_base: 'crosspacks',
+                     host_string: nil, host_os: Crossbuild::Platform.os,
+                     host_arch: Crossbuild::Platform.arch, selectors: Crossbuild::Platform.selectors)
+      config = Config.coerce(config, root: root)
+      target = host_target('install', host_string, host_arch)
+      pkg = validated_package(config)
+
+      command = config.install_manifest.command_for(selectors)
+      raise Error, pkgbuild_hint(target, root, output_base) if command.nil? && target.format == :pkgbuild
+
+      # {{path}} resolves to the package file (for arch: the PKGBUILD dir).
+      path = target.format == :pkgbuild ? packed_dir(target, root, output_base)
+                                        : package_file(target, pkg, root, output_base)
+      command ||= default_install_command(target.format)
+
+      execute(command, path: path, pkg: pkg, target: target, root: root, args: args)
+    end
+
+    # -- defaults ------------------------------------------------------------
+
+    # A macOS .app bundle must be opened, not exec'd; plain binaries and
+    # Windows exes run directly.
+    def self.default_run_command(path, host_os)
+      host_os == :darwin && File.directory?(path) ? 'open {{path}}' : '{{path}}'
+    end
+
+    def self.default_install_command(format)
+      case format
+      when :deb, :rpm   then 'xdg-open {{path}}'
+      when :winget      then 'msiexec /i {{path}}'
+      when :cask        then 'open {{path}}'
+      else
+        raise Error, "install: no default installer command for format #{format.inspect} — " \
+                     'add an install: section with hosts: rules to crosspack.yml'
+      end
+    end
+
+    # -- internals -----------------------------------------------------------
+
+    class << self
+      private
+
+      # "this host's target" — the same detection the stage commands use.
+      def host_target(command, host_string, host_arch)
+        raw = host_string || Target.host_string
+        if raw.nil?
+          raise Error,
+                "Could not detect this host's target — crosspack #{command} runs only on this host " \
+                '(families: ubuntu-24.04, debian-12, fedora-41, arch, macos, windows-11.0)'
+        end
+
+        Target.parse(raw, arch: host_arch)
+      end
+
+      def validated_package(config)
+        pkg = config.package_manifest
+        pkg.validate!
+        pkg
+      end
+
+      def packed_dir(target, root, output_base)
+        File.expand_path(target.output_dir(output_base, target.format), root)
+      end
+
+      # The packed tree must exist before any installer runs — even with a
+      # custom command (its {{path}} resolves into this directory).
+      def check_packed_dir(target, root, output_base)
+        dir = packed_dir(target, root, output_base)
+        return if File.directory?(dir)
+
+        raise Error,
+              "Pack stage not done for target #{target}: expected a packed package in #{dir}.\n" \
+              "Run: crosspack pack #{target}"
+      end
+
+      # The single package file this host's installer should receive.
+      def package_file(target, pkg, root, output_base)
+        check_packed_dir(target, root, output_base)
+        dir = packed_dir(target, root, output_base)
+        file =
+          case target.format
+          when :deb    then newest(dir, '*.deb')
+          when :rpm    then newest(dir, '*.rpm')
+          when :winget then newest(dir, '*.msi')
+          when :cask   then newest(dir, '*.dmg') || app_bundle(dir, pkg.name)
+          end
+
+        if file.nil?
+          raise winget_sources_hint(dir) if target.format == :winget && Dir[File.join(dir, '*.wxs')].any?
+
+          raise Error,
+                "No package for target #{target} in #{dir} — the pack stage produced nothing this " \
+                "command recognizes.\nRun: crosspack pack #{target}"
+        end
+        file
+      end
+
+      def newest(dir, pattern)
+        Dir[File.join(dir, pattern)].max_by { |f| File.mtime(f) }
+      end
+
+      def app_bundle(dir, name)
+        app = File.join(dir, "#{name}.app")
+        File.directory?(app) ? app : nil
+      end
+
+      def winget_sources_hint(dir)
+        'install: the pack stage produced only WiX sources (.wxs) — build the MSI first, ' \
+          "see #{File.join(dir, 'BUILD-MSI.txt')}"
+      end
+
+      def pkgbuild_hint(target, root, output_base)
+        "install: packing for #{target} generates a PKGBUILD, not a built package — " \
+          "install it yourself:\n  cd #{packed_dir(target, root, output_base)} && makepkg -si\n" \
+          'or add an install: section with hosts: rules to crosspack.yml'
+      end
+
+      # Expands the {{...}} placeholders, appends extra CLI args and runs the
+      # command from the project root, passing the child's exit code through.
+      def execute(command, path:, pkg:, target:, root:, args:)
+        vars = {
+          name: pkg.name,
+          version: Builds.version_for(target, File.expand_path(pkg.sources, root)).to_s,
+          os: target.family.to_s,
+          arch: Crossbuild::Platform.display_arch(target.arch == :any ? :x86_64 : target.arch),
+          platform: target.to_s,
+          path: path
+        }
+        command = Crossbuild::Runner.new(root: root, vars: vars).interpolate(command)
+        command = "#{command} #{args.join(' ')}" unless args.empty?
+
+        puts "▶ #{command}"
+        result = system(command, chdir: root)
+        raise Error, "launch failed (command not found): #{command}" if result.nil?
+
+        $?.exitstatus || 0
+      end
+    end
+  end
+end

data/lib/crosspack/version.rb

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

data/lib/crosspack.rb

@@ -1,15 +1,24 @@
 # frozen_string_literal: true
 
 require_relative 'crosspack/version'
+
+module Crosspack
+  # A stage failed (deps/build/pack/launch). Defined before the requires:
+  # launcher.rb subclasses it at load time.
+  class BuildError < StandardError; end
+end
+
 require_relative 'crosspack/colors'
 require_relative 'crosspack/target'
 require_relative 'crosspack/manifest'
+require_relative 'crosspack/command_manifest'
 require_relative 'crosspack/package_manifest'
 require_relative 'crosspack/config'
 require_relative 'crosspack/resolver'
 require_relative 'crosspack/matrix'
 require_relative 'crosspack/builds'
 require_relative 'crosspack/packer'
+require_relative 'crosspack/launcher'
 require_relative 'crosspack/builders/deb'
 require_relative 'crosspack/builders/rpm'
 require_relative 'crosspack/builders/pkgbuild'
@@ -30,7 +39,6 @@ module Crosspack
   #   files:       { source_path => destination_inside_package (no leading /) }
   #   symlinks:    { link_path_inside_package => link_target }
   #   executables: [destination paths to chmod 0755]
-  class BuildError < StandardError; end
 
   # Convenience wrapper: Crosspack.pack(config: 'crosspack.yml',
   # target: Target.parse('debian-12'), version: '1.0-1')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crosspack
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Oleg Orlov
@@ -57,7 +57,9 @@ files:
 - lib/crosspack/builders/wix.rb
 - lib/crosspack/builds.rb
 - lib/crosspack/colors.rb
+- lib/crosspack/command_manifest.rb
 - lib/crosspack/config.rb
+- lib/crosspack/launcher.rb
 - lib/crosspack/manifest.rb
 - lib/crosspack/matrix.rb
 - lib/crosspack/package_manifest.rb