vagrant-qemu 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35de3b54145ee419e9cada4bd6b879fa0e9f7faef93e27da8e750346dcd6c0b7
-  data.tar.gz: 8e0069a3cce24d59ab4723108bd54199cb6019a8a47c587601795bd6a9cc91a1
+  metadata.gz: b0968c034faf465b2d51e1f7b785a7a1aed39a4d6c40ef96f6b34147e9ab8ebd
+  data.tar.gz: fff8fc272c6c99abb85ccff761137f53ee6aabe8953f4b702ffca61163ea8d27
 SHA512:
-  metadata.gz: de578f059ba6ee08339738a906e366f8b8f33acc7b6389b05d68af4d365ceb6829e6d2ac7cf84214d7ff5f7af8510d657228ebd08fa0f444d40a962e23001cae
-  data.tar.gz: 5f74816cd5c18bf5ad492e546fea36d972b32585ebb0f360f1bd6cf2bbe70e475ea69365f6ff228addb5d8179feaa7944d74bfd80f4982dbd80eb7d2c7605a1b
+  metadata.gz: ba77c0b50cd06921799dcc154f8d987a3fe1e367fd4347bbd2a45381f0819815e9f832f29be04a76818fb5e5c24abb4f009fb33350aace09486f1a20f6250012
+  data.tar.gz: 6438ed9c811e25f7393e59971028eea43b5f3d76ac9a11982dd2424c8b7cbd54181cbaa514875aebbb54f38520fcab12575929e5c62259f42c37cce83274c34a

data/CHANGELOG.md

@@ -101,6 +101,14 @@
 * Add support for cloud-init and disks
 * Add support for resizing disk on vm setup
 
+# 0.4.1 (2026-06-22)
+
+* `vagrant halt` now reaps QEMU even when the guest was already halted from
+  inside (e.g. `sudo systemctl halt`), where the ACPI `system_powerdown` is a
+  no-op. Halt escalates: `system_powerdown` -> wait `graceful_timeout` -> QEMU
+  `quit` monitor command (clean: flushes and closes the disk images) -> wait
+  `graceful_timeout` -> SIGKILL as a last resort (#79)
+
 # 0.4.0 (2026-06-12)
 
 * Advanced networking (opt-in, `advanced_network = true`): dual-NIC `private_network`
@@ -132,3 +140,17 @@
 * Warn when private_network is configured without `advanced_network`, when the
   network backend needs sudo, and when other unsupported network types are used
 * Add test suite: unit + acceptance + e2e (`rake spec:unit|acceptance|e2e`)
+
+# 0.5.0 (2026-07-11)
+
+* `vagrant package` is now supported: export a running QEMU VM into a
+  distributable libvirt-format box. The box disk is flattened from its qcow2
+  overlay into a standalone qcow2 with `qemu-img convert` (the live VM disk is
+  never modified). A single-disk VM produces `box.img`; a multi-disk VM
+  produces `box_1.img`..`box_N.img` plus a `disks[]` entry in `metadata.json`.
+  `metadata.json` is written with `provider: libvirt` / `format: qcow2` /
+  `virtual_size`, and a minimal default Vagrantfile declaring the box `arch` is
+  bundled. `--output`/`--include`/`--info`/`--vagrantfile` are handled by the
+  core packaging middleware. Environment-specific state — networking, MAC,
+  additional disks, DVDs/cloud-init seed ISOs, and firmware — is intentionally
+  not baked into the box.

data/README.md

@@ -105,7 +105,7 @@ This provider exposes a few provider-specific configuration options:
   * `firmware_format` - The format of aarch64 firmware images (`edk2-aarch64-code.fd` and `edk2-arm-vars.fd`) loaded from `qemu_dir`, default: `raw`
   * `other_default` - The other default arguments used by this plugin, default: `%W(-parallel null -monitor none -display none -vga none)`
   * `extra_image_opts` - Options passed via `-o` to `qemu-img` when the base qcow2 images are created, default: `[]`
-  * `graceful_timeout` - Seconds to wait for the guest to shut down on `vagrant halt` before the QEMU process is force-killed, default: `60`
+  * `graceful_timeout` - Seconds to wait at each `vagrant halt` stage before escalating, default: `60`. Halt sends ACPI `system_powerdown`, waits up to this long, then sends QEMU's `quit` monitor command (a clean shutdown that flushes and closes the disk images), waits again, and finally SIGKILLs QEMU as a last resort — so halt still completes even when the guest was already halted from inside (e.g. `sudo systemctl halt`), where `system_powerdown` is a no-op
 * advanced networking (requires `advanced_network = true`)
   * `advanced_network` - Enable dual-NIC advanced networking with `private_network` support, default: `false`
   * `net_mode` - Network backend: `:auto` (detect by platform), `:vmnet_shared`, `:vmnet_host`, `:vmnet_bridged` (macOS), `:tap` (Linux), `:socket` (QEMU `socket` netdev — multicast or point-to-point, see `socket_opts`), default: `:auto`

data/lib/vagrant-qemu/action/export.rb

@@ -0,0 +1,74 @@
+require "json"
+require "open3"
+require "pathname"
+require "log4r"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      # Produces the box's disk artifacts and metadata.json in export.temp_dir:
+      # flattens each box-disk overlay into a standalone qcow2 and describes them
+      # in a libvirt-format metadata.json. Only the VM's box disks are packaged;
+      # additional disks, DVDs and cloud-init seed ISOs are left out.
+      class Export
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_qemu::action::export")
+        end
+
+        def call(env)
+          @env = env
+
+          if env[:machine].state.id != :stopped
+            raise Vagrant::Errors::VMPowerOffToPackage
+          end
+
+          export
+          @app.call(env)
+        end
+
+        def export
+          driver   = @env[:machine].provider.driver
+          temp_dir = Pathname.new(@env["export.temp_dir"])
+          disks    = driver.box_disk_paths
+
+          if disks.empty?
+            raise Errors::BoxInvalid, name: @env[:machine].name, err: "No box disk found to package"
+          end
+
+          multi     = disks.size > 1
+          disk_meta = []
+          disks.each_with_index do |src, i|
+            name = multi ? "box_#{i + 1}.img" : "box.img"
+            @env[:ui].info(I18n.t("vagrant_qemu.packaging_disk", name: name))
+            driver.convert_box_disk(src, temp_dir.join(name))
+            disk_meta << { "path" => name }
+          end
+
+          write_metadata(temp_dir, disk_meta, multi)
+        end
+
+        # libvirt box metadata: provider must be "libvirt" (the provider's
+        # box_format) or the packaged box won't match on `box add`.
+        def write_metadata(temp_dir, disk_meta, multi)
+          metadata = {
+            "provider"     => "libvirt",
+            "format"       => "qcow2",
+            "virtual_size" => virtual_size_gb(temp_dir.join(disk_meta.first["path"])),
+          }
+          metadata["disks"] = disk_meta if multi
+          File.write(temp_dir.join("metadata.json"), JSON.pretty_generate(metadata))
+        end
+
+        def virtual_size_gb(img)
+          stdout, stderr, status = Open3.capture3("qemu-img", "info", "--output=json", img.to_s)
+          if !status.success?
+            raise Errors::ExecuteError, command: "qemu-img info", stderr: stderr, stdout: stdout
+          end
+          bytes = JSON.parse(stdout)["virtual-size"]
+          (bytes.to_f / (1024**3)).ceil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/action/package_vagrantfile.rb

@@ -0,0 +1,37 @@
+require "pathname"
+
+module VagrantPlugins
+  module QEMU
+    module Action
+      # Writes a minimal default Vagrantfile into the box declaring only the
+      # architecture, so a consumer on a different host arch doesn't default to
+      # the wrong one. Networking, MAC and host-specific machine flags are left
+      # out on purpose — they are environment-specific and come from the
+      # consuming Vagrantfile. The core Package middleware appends the SSH
+      # private-key config to this same file afterwards.
+      class PackageVagrantfile
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+          create_vagrantfile
+          @app.call(env)
+        end
+
+        def create_vagrantfile
+          arch = @env[:machine].provider_config.arch
+          path = Pathname.new(@env["export.temp_dir"]).join("Vagrantfile")
+          File.write(path, <<~VF)
+            Vagrant.configure("2") do |config|
+              config.vm.provider :qemu do |qe|
+                qe.arch = "#{arch}"
+              end
+            end
+          VF
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/action.rb

@@ -9,8 +9,21 @@ module VagrantPlugins
       include Vagrant::Action::Builtin
 
       def self.action_package
-        lambda do |env|
-          raise Errors::NotSupportedError
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsState, :not_created do |env, b2|
+            if env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Vagrant::Action::General::PackageSetupFolders
+            b2.use Vagrant::Action::General::PackageSetupFiles
+            b2.use StopInstance
+            b2.use Vagrant::Action::General::Package
+            b2.use Export
+            b2.use PackageVagrantfile
+          end
         end
       end
 
@@ -173,6 +186,8 @@ module VagrantPlugins
       autoload :Import, action_root.join("import")
       autoload :StartInstance, action_root.join("start_instance")
       autoload :StopInstance, action_root.join("stop_instance")
+      autoload :Export, action_root.join("export")
+      autoload :PackageVagrantfile, action_root.join("package_vagrantfile")
       autoload :Destroy, action_root.join("destroy")
       autoload :CloudInitNetwork, action_root.join("cloud_init_network")
       autoload :TimedProvision, action_root.join("timed_provision") # some plugins now expect this action to exist

data/lib/vagrant-qemu/driver.rb

@@ -212,10 +212,27 @@ module VagrantPlugins
       end
 
       def stop(options)
-        if running?
-          send_powerdown(with_persisted_control_port(options))
-          wait_for_shutdown(options[:graceful_timeout] || 60)
-        end
+        return unless running?
+
+        opts = with_persisted_control_port(options)
+        timeout = options[:graceful_timeout] || 60
+
+        # 1. ACPI power button (graceful). Only works if a live guest OS is
+        #    there to act on it -- e.g. NOT after `systemctl halt`, which leaves
+        #    QEMU running with a halted, unresponsive guest.
+        send_monitor(opts, "system_powerdown")
+        return unless still_running_after?(timeout)
+
+        # 2. Powerdown didn't take. Ask QEMU itself to quit: it stops the VM,
+        #    flushes and closes the qcow2 images, then exits cleanly. Does not
+        #    depend on the guest, only on the monitor being reachable.
+        @logger.warn("VM did not power down within #{timeout}s; sending 'quit' to QEMU")
+        send_monitor(opts, "quit")
+        return unless still_running_after?(timeout)
+
+        # 3. Last resort: SIGKILL the QEMU process (no flush/cleanup).
+        @logger.warn("VM still running after 'quit'; forcing kill")
+        force_kill
       end
 
       private
@@ -232,35 +249,37 @@ module VagrantPlugins
         options.merge(:control_port => persisted[:control_port])
       end
 
-      def send_powerdown(options)
+      # Send a single QEMU monitor command over the control channel (TCP
+      # control_port if set, else the unix monitor socket). Best-effort: the
+      # socket may already be gone (e.g. QEMU exited from a prior command), so
+      # connection errors are swallowed.
+      def send_monitor(options, command)
         if !options[:control_port].nil?
           Socket.tcp("localhost", options[:control_port], connect_timeout: 5) do |sock|
-            sock.print "system_powerdown\n"
+            sock.print "#{command}\n"
             sock.close_write
             sock.read rescue nil
           end
         else
-          id_tmp_dir = @tmp_dir.join(@vm_id)
-          unix_socket_path = id_tmp_dir.join("qemu_socket").to_s
+          unix_socket_path = @tmp_dir.join(@vm_id).join("qemu_socket").to_s
           Socket.unix(unix_socket_path) do |sock|
-            sock.print "system_powerdown\n"
+            sock.print "#{command}\n"
             sock.close_write
             sock.read rescue nil
           end
         end
+      rescue => e
+        @logger.debug("monitor command '#{command}' failed: #{e}") if @logger
       end
 
-      def wait_for_shutdown(timeout)
+      # Poll for up to `timeout` seconds. Return false as soon as the VM has
+      # stopped; return true if it is still running when the timeout elapses.
+      def still_running_after?(timeout)
         timeout.times do
-          return unless running?
+          return false unless running?
           sleep 1
         end
-
-        # Still running after timeout, force kill
-        if running?
-          @logger.warn("VM did not shut down within #{timeout}s, forcing kill")
-          force_kill
-        end
+        running?
       end
 
       def force_kill
@@ -455,6 +474,25 @@ module VagrantPlugins
       def disk_dir
           @data_dir.join(@vm_id)
       end
+
+      # Ordered paths of the box's disk overlays, reconstructed by index to
+      # match start/import (glob only counts; names rebuild by index so a
+      # two-digit suffix can't sort ahead of a single digit).
+      def box_disk_paths
+        id_dir = disk_dir
+        count = id_dir.glob("linked-box*.img").count
+        (0...count).map do |i|
+          suffix = i > 0 ? "-#{i}" : ""
+          id_dir.join("linked-box#{suffix}.img")
+        end
+      end
+
+      # Flatten a box disk overlay into a standalone qcow2 at dst. convert reads
+      # the whole backing chain and writes a fresh file, so the source overlay
+      # (the live VM disk) is never modified.
+      def convert_box_disk(src, dst)
+        execute("qemu-img", "convert", "-O", "qcow2", src.to_s, dst.to_s)
+      end
     end
   end
 end

data/lib/vagrant-qemu/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module QEMU
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

data/locales/en.yml

@@ -15,6 +15,8 @@ en:
       Stopping the instance...
     destroying: |-
       Destroying the instance...
+    packaging_disk: |-
+      Exporting box disk: %{name}
     warn_networks: |-
       Warning! The QEMU provider doesn't support any of the Vagrant
       high-level network configurations (`config.vm.network`). They

data/spec/e2e/halt_spec.rb

@@ -0,0 +1,48 @@
+require_relative "helper"
+
+# Regression for #79: `vagrant halt` must actually reap QEMU even when the
+# guest OS was already halted from inside (e.g. `sudo systemctl halt`). In that
+# state the ACPI `system_powerdown` is a no-op (no live guest to act on it), so
+# halt has to escalate to QEMU's `quit` monitor command and, failing that, to
+# SIGKILL. A short graceful_timeout keeps the escalation fast.
+describe "halt reaps QEMU when the guest is already halted (#79)", :requires_qemu do
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @work_dir = dir.join("project")
+      FileUtils.mkdir_p(@work_dir)
+
+      File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+        Vagrant.configure("2") do |config|
+          config.vm.box = "#{test_box}"
+          config.vm.box_check_update = false
+          config.vm.synced_folder ".", "/vagrant", disabled: true
+          config.vm.provider "qemu" do |qe|
+            qe.memory = "2G"
+            qe.graceful_timeout = 5
+          end
+        end
+      RUBY
+
+      example.run
+
+      vagrant_destroy(@work_dir) rescue nil
+    end
+  end
+
+  it "stops the VM after the guest was halted from inside" do
+    vagrant_up(@work_dir)
+
+    # Halt the guest OS from inside; the SSH connection drops as it goes down,
+    # so ignore the result. After this, system_powerdown can no longer work.
+    vagrant_ssh(@work_dir, command: "sudo systemctl halt", timeout: 30) rescue nil
+    sleep 3
+
+    # Without the escalation, QEMU would linger and the VM would still report
+    # running; with it, halt reaps the process within ~graceful_timeout.
+    result = vagrant_halt(@work_dir, timeout: 60)
+    expect(result[:exit_code]).to eq 0
+
+    status = vagrant_status(@work_dir)
+    expect(status[:stdout]).to include(",state,stopped")
+  end
+end

data/spec/e2e/helper.rb

@@ -73,6 +73,18 @@ module E2EHelper
     run_vagrant_cmd("status", "--machine-readable", cwd: cwd, timeout: 15)
   end
 
+  def vagrant_package(cwd, output:, timeout: 600)
+    run_vagrant_cmd("package", "--output", output.to_s, cwd: cwd, timeout: timeout)
+  end
+
+  def vagrant_box_add(name, path, cwd:, timeout: 120)
+    run_vagrant_cmd("box", "add", name, path.to_s, "--force", cwd: cwd, timeout: timeout)
+  end
+
+  def vagrant_box_remove(name, cwd:, timeout: 60)
+    run_vagrant_cmd("box", "remove", name, "--force", cwd: cwd, timeout: timeout)
+  end
+
   private
 
   def run_vagrant_cmd(*args, cwd:, timeout: 120)

data/spec/e2e/package_spec.rb

@@ -0,0 +1,95 @@
+require_relative "helper"
+
+# End-to-end round-trip for `vagrant package`. Exercises the INSTALLED plugin
+# (see helper.rb), so rebuild + reinstall before running:
+#   bundle exec rake build && vagrant plugin install ./pkg/vagrant-qemu-<ver>.gem
+#   TEST_QEMU=1 bundle exec rake spec:e2e
+describe "vagrant package end-to-end", :requires_qemu do
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @work_dir = dir.join("project")
+      @consume_dir = dir.join("consumer")
+      @box_path = dir.join("packaged.box")
+      FileUtils.mkdir_p(@work_dir)
+      FileUtils.mkdir_p(@consume_dir)
+      example.run
+      vagrant_destroy(@consume_dir) rescue nil
+      vagrant_destroy(@work_dir) rescue nil
+      vagrant_box_remove("e2e-packaged", cwd: @work_dir) rescue nil
+    end
+  end
+
+  def write_source_vagrantfile
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+        end
+      end
+    RUBY
+  end
+
+  it "packages a running VM into a box that boots again (round-trip)" do
+    write_source_vagrantfile
+    expect(vagrant_up(@work_dir)[:exit_code]).to eq 0
+
+    result = vagrant_package(@work_dir, output: @box_path)
+    expect(result[:exit_code]).to eq 0
+    expect(File.exist?(@box_path)).to be true
+
+    # Box layout: box.img + metadata.json + Vagrantfile.
+    listing = `tar tzf #{@box_path}`
+    expect(listing).to include("box.img")
+    expect(listing).to include("metadata.json")
+    expect(listing).to include("Vagrantfile")
+
+    # box.img must be a self-contained qcow2 (overlay flattened, no backing).
+    Dir.mktmpdir do |ex|
+      system("tar xzf #{@box_path} -C #{ex} box.img")
+      info = `qemu-img info --output=json #{File.join(ex, "box.img")}`
+      expect(info).to include('"format": "qcow2"')
+      expect(info).not_to match(/backing-filename/)
+    end
+
+    # Consume the packaged box in a fresh project and boot it.
+    expect(vagrant_box_add("e2e-packaged", @box_path, cwd: @work_dir)[:exit_code]).to eq 0
+    File.write(@consume_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "e2e-packaged"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+        end
+      end
+    RUBY
+    expect(vagrant_up(@consume_dir)[:exit_code]).to eq 0
+    expect(vagrant_ssh(@consume_dir, command: "echo roundtrip-ok")[:stdout]).to include("roundtrip-ok")
+  end
+
+  it "does not bake environment-specific network config into the box" do
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.network "forwarded_port", guest: 80, host: 8080, auto_correct: true
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+        end
+      end
+    RUBY
+    expect(vagrant_up(@work_dir)[:exit_code]).to eq 0
+    expect(vagrant_package(@work_dir, output: @box_path)[:exit_code]).to eq 0
+
+    Dir.mktmpdir do |ex|
+      system("tar xzf #{@box_path} -C #{ex} Vagrantfile")
+      vf = File.read(File.join(ex, "Vagrantfile"))
+      expect(vf).to include("qe.arch")
+      expect(vf).not_to match(/forwarded_port|network|8080/)
+    end
+  end
+end

data/spec/unit/action/export_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+require "json"
+require "vagrant-qemu/action/export"
+
+describe VagrantPlugins::QEMU::Action::Export do
+  let(:vm_id) { "vq_export" }
+  let(:app) { lambda { |env| } }
+  let(:ui) { double("ui", info: nil, detail: nil) }
+
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @data_dir = dir.join("data")
+      @tmp_base = dir.join("tmp")
+      @export_dir = dir.join("export")
+      FileUtils.mkdir_p(@data_dir.join(vm_id))
+      FileUtils.mkdir_p(@tmp_base)
+      FileUtils.mkdir_p(@export_dir)
+      example.run
+    end
+  end
+
+  let(:driver) { VagrantPlugins::QEMU::Driver.new(vm_id, @data_dir, @tmp_base) }
+  let(:provider) { double("provider", driver: driver) }
+  let(:state) { double("state", id: :stopped) }
+  let(:machine) do
+    c = VagrantPlugins::QEMU::Config.new
+    c.arch = "aarch64"
+    c.finalize!
+    double("machine", provider: provider, provider_config: c, name: "default", state: state)
+  end
+  let(:env) { { machine: machine, ui: ui, "export.temp_dir" => @export_dir.to_s } }
+
+  before do
+    VagrantPlugins::QEMU::Plugin.setup_i18n
+    # Don't invoke real qemu-img convert; just record calls.
+    allow(driver).to receive(:convert_box_disk)
+    # virtual-size from qemu-img info: 1 GiB + 1 byte → ceil to 2 GB.
+    status = double("status", success?: true)
+    allow(Open3).to receive(:capture3)
+      .and_return([JSON.generate("virtual-size" => (1024**3) + 1), "", status])
+  end
+
+  def metadata
+    JSON.parse(File.read(@export_dir.join("metadata.json")))
+  end
+
+  context "single box disk (v1)" do
+    before { FileUtils.touch(@data_dir.join(vm_id, "linked-box.img")) }
+
+    it "flattens the disk to box.img and writes libvirt v1 metadata (no disks[])" do
+      expect(driver).to receive(:convert_box_disk)
+        .with(@data_dir.join(vm_id, "linked-box.img"), @export_dir.join("box.img"))
+      described_class.new(app, env).call(env)
+
+      expect(metadata["provider"]).to eq "libvirt"
+      expect(metadata["format"]).to eq "qcow2"
+      expect(metadata["virtual_size"]).to eq 2
+      expect(metadata).not_to have_key("disks")
+    end
+  end
+
+  context "multiple box disks (v2)" do
+    before do
+      %w[linked-box.img linked-box-1.img].each { |n| FileUtils.touch(@data_dir.join(vm_id, n)) }
+    end
+
+    it "flattens each disk to box_N.img and writes disks[]" do
+      expect(driver).to receive(:convert_box_disk)
+        .with(@data_dir.join(vm_id, "linked-box.img"), @export_dir.join("box_1.img"))
+      expect(driver).to receive(:convert_box_disk)
+        .with(@data_dir.join(vm_id, "linked-box-1.img"), @export_dir.join("box_2.img"))
+      described_class.new(app, env).call(env)
+
+      expect(metadata["disks"]).to eq([{ "path" => "box_1.img" }, { "path" => "box_2.img" }])
+    end
+  end
+
+  context "environment-specific artifacts present" do
+    before do
+      FileUtils.touch(@data_dir.join(vm_id, "linked-box.img"))
+      FileUtils.touch(@data_dir.join(vm_id, "extra-data.qcow2"))
+      FileUtils.touch(@data_dir.join(vm_id, "vagrant-qemu-network.iso"))
+    end
+
+    it "packages only the box disk, not additional disks or ISOs" do
+      expect(driver).to receive(:convert_box_disk).once
+        .with(@data_dir.join(vm_id, "linked-box.img"), @export_dir.join("box.img"))
+      described_class.new(app, env).call(env)
+      expect(metadata).not_to have_key("disks")
+    end
+  end
+
+  context "VM not powered off" do
+    let(:state) { double("state", id: :running) }
+    before { FileUtils.touch(@data_dir.join(vm_id, "linked-box.img")) }
+
+    it "raises and does not convert" do
+      expect(driver).not_to receive(:convert_box_disk)
+      expect { described_class.new(app, env).call(env) }
+        .to raise_error(Vagrant::Errors::VMPowerOffToPackage)
+    end
+  end
+end

data/spec/unit/action/package_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe VagrantPlugins::QEMU::Action, "#action_package" do
+  it "returns a runnable builder instead of raising NotSupportedError" do
+    expect(described_class.action_package).to be_a(Vagrant::Action::Builder)
+  end
+
+  it "no longer raises (package is supported now)" do
+    expect { described_class.action_package }.not_to raise_error
+  end
+
+  it "validates config and branches on machine state at the top of the chain" do
+    klasses = described_class.action_package.stack.map(&:first)
+    expect(klasses).to include(Vagrant::Action::Builtin::ConfigValidate)
+    expect(klasses).to include(Vagrant::Action::Builtin::Call)
+  end
+
+  it "autoloads the Export and PackageVagrantfile actions" do
+    expect { described_class::Export }.not_to raise_error
+    expect { described_class::PackageVagrantfile }.not_to raise_error
+  end
+end

data/spec/unit/action/package_vagrantfile_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+require "vagrant-qemu/action/package_vagrantfile"
+
+describe VagrantPlugins::QEMU::Action::PackageVagrantfile do
+  let(:app) { lambda { |env| } }
+  let(:ui) { double("ui", info: nil) }
+
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @export_dir = dir.join("export")
+      FileUtils.mkdir_p(@export_dir)
+      example.run
+    end
+  end
+
+  def machine_with(arch)
+    c = VagrantPlugins::QEMU::Config.new
+    c.arch = arch
+    c.finalize!
+    double("machine", provider_config: c)
+  end
+
+  def run(arch)
+    env = { machine: machine_with(arch), ui: ui, "export.temp_dir" => @export_dir.to_s }
+    described_class.new(app, env).call(env)
+    File.read(@export_dir.join("Vagrantfile"))
+  end
+
+  it "writes the VM arch into the default Vagrantfile" do
+    expect(run("aarch64")).to include('qe.arch = "aarch64"')
+  end
+
+  it "carries a different arch through" do
+    expect(run("x86_64")).to include('qe.arch = "x86_64"')
+  end
+
+  it "does not bake environment-specific network/MAC/machine config" do
+    vf = run("aarch64")
+    expect(vf).not_to match(/network|base_mac|accel|machine/i)
+  end
+end

data/spec/unit/driver/package_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe VagrantPlugins::QEMU::Driver, "package helpers" do
+  let(:vm_id) { "vq_pkgtest" }
+
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @data_dir = dir.join("data")
+      @tmp_base = dir.join("tmp")
+      FileUtils.mkdir_p(@data_dir.join(vm_id))
+      FileUtils.mkdir_p(@tmp_base)
+      example.run
+    end
+  end
+
+  subject { described_class.new(vm_id, @data_dir, @tmp_base) }
+
+  describe "#box_disk_paths" do
+    it "enumerates box disks by index, matching start/import order (not glob lexical)" do
+      id_dir = @data_dir.join(vm_id)
+      # Create out of lexical order incl. a two-digit index to catch lexical-sort bugs.
+      %w[linked-box.img linked-box-1.img linked-box-2.img].each { |n| FileUtils.touch(id_dir.join(n)) }
+
+      expect(subject.box_disk_paths.map { |p| File.basename(p) })
+        .to eq %w[linked-box.img linked-box-1.img linked-box-2.img]
+    end
+
+    it "returns a single box.img overlay for a single-disk VM" do
+      FileUtils.touch(@data_dir.join(vm_id, "linked-box.img"))
+      expect(subject.box_disk_paths.map { |p| File.basename(p) }).to eq %w[linked-box.img]
+    end
+
+    it "excludes additional disks and ISOs (only linked-box*.img are box disks)" do
+      id_dir = @data_dir.join(vm_id)
+      FileUtils.touch(id_dir.join("linked-box.img"))
+      FileUtils.touch(id_dir.join("extra-data.qcow2"))
+      FileUtils.touch(id_dir.join("vagrant-qemu-network.iso"))
+
+      expect(subject.box_disk_paths.map { |p| File.basename(p) }).to eq %w[linked-box.img]
+    end
+  end
+
+  describe "#convert_box_disk" do
+    it "flattens via qemu-img convert to a fresh qcow2 (never mutates the source)" do
+      src = @data_dir.join(vm_id, "linked-box.img")
+      dst = @data_dir.join(vm_id, "box.img")
+      expect(subject).to receive(:execute).with("qemu-img", "convert", "-O", "qcow2", src.to_s, dst.to_s)
+      subject.convert_box_disk(src, dst)
+    end
+  end
+end

data/spec/unit/driver/stop_spec.rb

@@ -16,47 +16,55 @@ describe VagrantPlugins::QEMU::Driver, "#stop" do
   subject { described_class.new(vm_id, @data_dir, @tmp_base) }
 
   it "does nothing when not running" do
-    expect(subject).not_to receive(:send_powerdown)
+    allow(subject).to receive(:running?).and_return(false)
+    expect(subject).not_to receive(:send_monitor)
     subject.stop(control_port: nil)
   end
 
-  it "sends powerdown when running" do
+  it "sends system_powerdown first and stops there when the guest powers off" do
+    # running on the initial check, stopped on the first poll
     allow(subject).to receive(:running?).and_return(true, false)
-    allow(subject).to receive(:send_powerdown)
+    allow(subject).to receive(:send_monitor)
 
-    subject.stop(control_port: nil)
+    subject.stop(control_port: nil, graceful_timeout: 5)
 
-    expect(subject).to have_received(:send_powerdown)
+    expect(subject).to have_received(:send_monitor).with(anything, "system_powerdown")
+    expect(subject).not_to have_received(:send_monitor).with(anything, "quit")
   end
 
-  it "returns when VM shuts down within timeout" do
-    call_count = 0
-    allow(subject).to receive(:running?) do
-      call_count += 1
-      call_count <= 1 # running on first call, stopped on second
-    end
-    allow(subject).to receive(:send_powerdown)
+  it "escalates to 'quit' when powerdown does not stop the VM" do
+    allow(subject).to receive(:sleep)
+    # stays up through the powerdown wait, then stops during the quit wait
+    allow(subject).to receive(:running?).and_return(true, true, true, false)
+    allow(subject).to receive(:send_monitor)
+    expect(subject).not_to receive(:force_kill)
 
-    subject.stop(control_port: nil, graceful_timeout: 5)
+    subject.stop(control_port: nil, graceful_timeout: 1)
+
+    expect(subject).to have_received(:send_monitor).with(anything, "system_powerdown").ordered
+    expect(subject).to have_received(:send_monitor).with(anything, "quit").ordered
   end
 
-  it "force kills when VM does not shut down within timeout" do
-    allow(subject).to receive(:running?).and_return(true)
-    allow(subject).to receive(:send_powerdown)
+  it "force kills only after both powerdown and 'quit' fail" do
     allow(subject).to receive(:sleep)
+    allow(subject).to receive(:running?).and_return(true) # never stops
+    allow(subject).to receive(:send_monitor)
 
     pid_dir = @tmp_base.join("vagrant-qemu", vm_id)
     FileUtils.mkdir_p(pid_dir)
     File.write(pid_dir.join("qemu.pid"), "999999999")
-
     allow(Process).to receive(:kill).with("KILL", 999999999).and_raise(Errno::ESRCH)
 
-    expect { subject.stop(control_port: nil, graceful_timeout: 1) }.not_to raise_error
+    subject.stop(control_port: nil, graceful_timeout: 1)
+
+    expect(subject).to have_received(:send_monitor).with(anything, "system_powerdown")
+    expect(subject).to have_received(:send_monitor).with(anything, "quit")
+    expect(Process).to have_received(:kill).with("KILL", 999999999)
   end
 
   it "prefers the persisted control_port over the configured one" do
     allow(subject).to receive(:running?).and_return(true, false)
-    allow(subject).to receive(:send_powerdown)
+    allow(subject).to receive(:send_monitor)
 
     opts_dir = @tmp_base.join("vagrant-qemu", vm_id)
     FileUtils.mkdir_p(opts_dir)
@@ -64,29 +72,28 @@ describe VagrantPlugins::QEMU::Driver, "#stop" do
 
     subject.stop(control_port: 33333)
 
-    expect(subject).to have_received(:send_powerdown)
-      .with(hash_including(control_port: 44444))
+    expect(subject).to have_received(:send_monitor)
+      .with(hash_including(control_port: 44444), "system_powerdown")
   end
 
   it "keeps the configured control_port when nothing is persisted" do
     allow(subject).to receive(:running?).and_return(true, false)
-    allow(subject).to receive(:send_powerdown)
+    allow(subject).to receive(:send_monitor)
 
     subject.stop(control_port: 33333)
 
-    expect(subject).to have_received(:send_powerdown)
-      .with(hash_including(control_port: 33333))
+    expect(subject).to have_received(:send_monitor)
+      .with(hash_including(control_port: 33333), "system_powerdown")
   end
 
-  it "swallows ESRCH on force_kill when process already gone" do
-    allow(subject).to receive(:running?).and_return(true)
-    allow(subject).to receive(:send_powerdown)
+  it "swallows ESRCH on force_kill when the process is already gone" do
     allow(subject).to receive(:sleep)
+    allow(subject).to receive(:running?).and_return(true)
+    allow(subject).to receive(:send_monitor)
 
     pid_dir = @tmp_base.join("vagrant-qemu", vm_id)
     FileUtils.mkdir_p(pid_dir)
     File.write(pid_dir.join("qemu.pid"), "999999999")
-
     allow(Process).to receive(:kill).and_raise(Errno::ESRCH)
 
     expect { subject.stop(control_port: nil, graceful_timeout: 1) }.not_to raise_error

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-qemu
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - ppggff
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-22 00:00:00.000000000 Z
+date: 2026-07-11 00:00:00.000000000 Z
 dependencies: []
 description: Enables Vagrant to manage machines with QEMU.
 email: pgf00a@gmail.com
@@ -27,10 +27,12 @@ files:
 - lib/vagrant-qemu/action.rb
 - lib/vagrant-qemu/action/cloud_init_network.rb
 - lib/vagrant-qemu/action/destroy.rb
+- lib/vagrant-qemu/action/export.rb
 - lib/vagrant-qemu/action/import.rb
 - lib/vagrant-qemu/action/message_already_created.rb
 - lib/vagrant-qemu/action/message_not_created.rb
 - lib/vagrant-qemu/action/message_will_not_destroy.rb
+- lib/vagrant-qemu/action/package_vagrantfile.rb
 - lib/vagrant-qemu/action/prepare_forwarded_port_collision_params.rb
 - lib/vagrant-qemu/action/read_state.rb
 - lib/vagrant-qemu/action/start_instance.rb
@@ -59,7 +61,9 @@ files:
 - spec/e2e/advanced_network_spec.rb
 - spec/e2e/disk_spec.rb
 - spec/e2e/forwarded_port_spec.rb
+- spec/e2e/halt_spec.rb
 - spec/e2e/helper.rb
+- spec/e2e/package_spec.rb
 - spec/e2e/provision_spec.rb
 - spec/e2e/reload_spec.rb
 - spec/e2e/smoke_spec.rb
@@ -67,7 +71,10 @@ files:
 - spec/spec_helper.rb
 - spec/unit/action/cloud_init_network_spec.rb
 - spec/unit/action/destroy_spec.rb
+- spec/unit/action/export_spec.rb
 - spec/unit/action/import_spec.rb
+- spec/unit/action/package_spec.rb
+- spec/unit/action/package_vagrantfile_spec.rb
 - spec/unit/action/prepare_forwarded_port_collision_params_spec.rb
 - spec/unit/action/read_state_spec.rb
 - spec/unit/action/start_instance_port_spec.rb
@@ -76,6 +83,7 @@ files:
 - spec/unit/config_spec.rb
 - spec/unit/driver/delete_spec.rb
 - spec/unit/driver/options_yaml_spec.rb
+- spec/unit/driver/package_spec.rb
 - spec/unit/driver/ssh_port_spec.rb
 - spec/unit/driver/start_cmd_advanced_spec.rb
 - spec/unit/driver/start_cmd_order_spec.rb