ace-demo 0.25.11 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3b676fa6096418bb3b8add01dce3d139ae7dee5e88ea2b768f5d2f32ffddc96
-  data.tar.gz: b63d955b3f701e6eb175fda99fe1a9e77cde86d80b6a3b122638581666ea99ed
+  metadata.gz: 58391984e07317e02abd29f0fe8153841f4d616aac0849ea916b020b2c8492c3
+  data.tar.gz: 48f1b66626923433238798ca500cd71143b5b05df3a6e6ae5163f6d83d707ce7
 SHA512:
-  metadata.gz: 29782f49a346664352492a93890573e0bd9eebd0c96b1e9fcabd6015334417898e916e437d7e4001f63512c7472b90e0ab7cef89aebd5f8581b6d2f7bdd05e2e
-  data.tar.gz: a8928d92b4719df5f1101ae89dc5617e582d6d3a30b8e017f031ef39f0e042488a5a70cd443246b08c0375990e748193b862fa31542cc9e910b43539d8a83b14
+  metadata.gz: 9cdcfb904e837ace1001c4960f80150ffb957a406428a7ee82f0f21a8851b7678e9322f8e23ea4f1ad56ff86b0aa492494978589f162e8f08026f40d00797ef5
+  data.tar.gz: d76d42482f636e3de108eb2f6f372f6c930730b4b9bf34d416580253813f0c8e649a26debb7508ced3f569c87b3c75cb2eb164137e905266fffd4e3225e92312

data/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.26.0] - 2026-10-04
+
+### Added
+- Demo terminal directives run through the `ace-runtime` contract (`TmuxDirectiveExecutor` replaced by `RuntimeDirectiveExecutor`): the four lifecycle wait conditions and send directives work on both adapters with identical semantics, with per-directive `runtime:` selection (directive > `ACE_RUNTIME` > configured > detection). `attach`/`detach` stay tmux-local and raise an explicit error under any other runtime.
+- New dependency: `ace-runtime` (~> 0.1); `ace-tmux` is kept for the tmux adapter and detach.
+
 ## [0.25.11] - 2026-10-02
 
 ### Technical

data/lib/ace/demo/molecules/runtime_directive_executor.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "ace/runtime"
+require "ace/tmux"
+require "shellwords"
+
+module Ace
+  module Demo
+    module Molecules
+      # Executes demo terminal directives through the runtime contract.
+      # wait/send resolve via the selected runtime adapter; attach/detach
+      # stay tmux-local human-facing operations (k86.0 validation default).
+      # The YAML envelope key remains "tmux" for tape compatibility of the
+      # directive shape itself; wait/send never touch tmux APIs directly.
+      class RuntimeDirectiveExecutor
+        LIFECYCLE_CONDITIONS = Ace::Runtime::Atoms::SendContract::LIFECYCLE_CONDITIONS
+        WINDOW_CONDITIONS = %w[window-exists window-active].freeze
+        DEFAULT_TIMEOUT = 10.0
+
+        def initialize(runtime: nil, env: ENV, tmux_executor: nil)
+          @runtime_override = runtime
+          @env = env || ENV
+          @tmux_executor = tmux_executor
+        end
+
+        def execute(command, env = nil)
+          directive_env = env || @env
+          directive = command.fetch("tmux")
+          action = directive.fetch("action")
+
+          case action
+          when "attach"
+            ensure_tmux_local!(directive, directive_env, action)
+            session = directive.fetch("session")
+            {shell_command: [tmux_binary, "attach-session", "-t", session].map { |part| Shellwords.escape(part) }.join(" ")}
+          when "detach"
+            ensure_tmux_local!(directive, directive_env, action)
+            session = directive.fetch("session")
+            tmux_executor.run([tmux_binary, "detach-client", "-s", session])
+            nil
+          when "wait"
+            wait_directive(directive, directive_env)
+            nil
+          when "send"
+            send_directive(directive, directive_env)
+            nil
+          else
+            raise ArgumentError, "Unsupported tmux action '#{action}'"
+          end
+        rescue KeyError => e
+          raise ArgumentError, "Invalid tmux directive: missing #{e.key}"
+        rescue Ace::Runtime::Error => e
+          raise Ace::Demo::Error, e.message
+        end
+
+        private
+
+        private
+
+        attr_reader :env, :runtime_override
+
+        # The adapter resolves per execute() call: the per-directive
+        # `runtime:` key and the caller environment are selection inputs,
+        # so a memoized adapter could route a later directive to the
+        # wrong runtime.
+        def adapter(directive, directive_env)
+          Ace::Runtime::Molecules::RuntimeSelector.new(
+            config: Ace::Runtime.config,
+            env: directive_env
+          ).resolve(explicit: directive_runtime(directive))
+        end
+
+        def wait_directive(directive, directive_env)
+          condition = directive.fetch("for")
+          unless LIFECYCLE_CONDITIONS.include?(condition)
+            raise ArgumentError, "wait condition must be one of: #{LIFECYCLE_CONDITIONS.join(', ')}"
+          end
+
+          target = if WINDOW_CONDITIONS.include?(condition)
+            required_target(directive, "window")
+          else
+            required_target(directive, "pane")
+          end
+          adapter(directive, directive_env).wait_lifecycle(
+            condition: condition,
+            target: target,
+            timeout: directive.fetch("timeout", DEFAULT_TIMEOUT)
+          )
+        end
+
+        def send_directive(directive, directive_env)
+          pane = required_target(directive, "pane")
+          runtime_adapter = adapter(directive, directive_env)
+          if directive["command"]
+            runtime_adapter.send_command(pane: pane, command: directive["command"])
+          else
+            runtime_adapter.send_keys(pane: pane, keys: [directive.fetch("key")])
+          end
+        end
+
+        def required_target(directive, kind)
+          target = directive[kind].to_s.strip
+          raise ArgumentError, "Invalid tmux directive: missing #{kind}" if target.empty?
+
+          target
+        end
+
+        # Selection precedence mirrors the contract selector: per-directive
+        # runtime > executor runtime > ACE_RUNTIME > configured runtime >
+        # detection. The name form is needed separately for the tmux-local
+        # guard, which must not resolve an adapter at all.
+        def selected_runtime_name(directive, directive_env)
+          directive_runtime(directive) ||
+            directive_env["ACE_RUNTIME"] ||
+            Ace::Runtime.config["runtime"] ||
+            Ace::Runtime.detect(env: directive_env)&.to_s ||
+            ""
+        end
+
+        def directive_runtime(directive)
+          explicit = (directive["runtime"] || runtime_override).to_s.strip
+          explicit.empty? ? nil : explicit
+        end
+
+        def ensure_tmux_local!(directive, directive_env, action)
+          selected = selected_runtime_name(directive, directive_env)
+          return if selected.empty? || selected == "tmux"
+
+          raise Ace::Demo::Error, "#{action} is tmux-local and unsupported under the '#{selected}' runtime"
+        end
+
+        def tmux_executor
+          @tmux_executor_instance ||= @tmux_executor || Ace::Tmux::Molecules::TmuxExecutor.new
+        end
+
+        def tmux_binary
+          "tmux"
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/organisms/demo_recorder.rb

@@ -19,7 +19,7 @@ module Ace
           yaml_compiler: Atoms::VhsTapeCompiler,
           asciinema_tape_compiler: Atoms::AsciinemaTapeCompiler,
           media_retimer: Molecules::MediaRetimer.new,
-          tmux_directive_executor: Molecules::TmuxDirectiveExecutor.new,
+          directive_executor: Molecules::RuntimeDirectiveExecutor.new,
           sandbox_builder: Molecules::DemoSandboxBuilder.new,
           teardown_executor: Molecules::DemoTeardownExecutor.new,
           output_dir: Demo.config["output_dir"],
@@ -38,7 +38,7 @@ module Ace
           @yaml_compiler = yaml_compiler
           @asciinema_tape_compiler = asciinema_tape_compiler
           @media_retimer = media_retimer
-          @tmux_directive_executor = tmux_directive_executor
+          @directive_executor = directive_executor
           @sandbox_builder = sandbox_builder
           @teardown_executor = teardown_executor
           @output_dir = output_dir || ".ace-local/demo"
@@ -268,7 +268,7 @@ module Ace
             write_io.flush
             nil
           when :tmux
-            @tmux_directive_executor.execute({"tmux" => command.fetch(:directive)}, env)
+            @directive_executor.execute({"tmux" => command.fetch(:directive)}, env)
           end
         end
 

data/lib/ace/demo/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Demo
-    VERSION = "0.25.11"
+    VERSION = "0.26.0"
   end
 end

data/lib/ace/demo.rb

@@ -2,7 +2,7 @@
 
 require "fileutils"
 require "ace/support/config"
-require "ace/tmux"
+require "ace/runtime"
 
 require_relative "demo/version"
 require_relative "demo/atoms/vhs_command_builder"
@@ -41,7 +41,7 @@ require_relative "demo/molecules/media_retimer"
 require_relative "demo/molecules/demo_comment_poster"
 require_relative "demo/molecules/verification_report_writer"
 require_relative "demo/molecules/recording_manifest_writer"
-require_relative "demo/molecules/tmux_directive_executor"
+require_relative "demo/molecules/runtime_directive_executor"
 require_relative "demo/organisms/demo_recorder"
 require_relative "demo/organisms/demo_attacher"
 require_relative "demo/organisms/tape_creator"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-demo
 version: !ruby/object:Gem::Version
-  version: 0.25.11
+  version: 0.26.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -65,6 +65,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: ace-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: ace-tmux
   requirement: !ruby/object:Gem::Requirement
@@ -200,10 +214,10 @@ files:
 - lib/ace/demo/molecules/inline_recorder.rb
 - lib/ace/demo/molecules/media_retimer.rb
 - lib/ace/demo/molecules/recording_manifest_writer.rb
+- lib/ace/demo/molecules/runtime_directive_executor.rb
 - lib/ace/demo/molecules/tape_resolver.rb
 - lib/ace/demo/molecules/tape_scanner.rb
 - lib/ace/demo/molecules/tape_writer.rb
-- lib/ace/demo/molecules/tmux_directive_executor.rb
 - lib/ace/demo/molecules/verification_report_writer.rb
 - lib/ace/demo/molecules/vhs_executor.rb
 - lib/ace/demo/organisms/demo_attacher.rb

data/lib/ace/demo/molecules/tmux_directive_executor.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require "shellwords"
-
-module Ace
-  module Demo
-    module Molecules
-      class TmuxDirectiveExecutor
-        def initialize(control_surface: nil, executor: nil, tmux: "tmux")
-          @control_surface = control_surface
-          @executor = executor || Ace::Tmux::Molecules::TmuxExecutor.new
-          @tmux = tmux
-        end
-
-        def execute(command, env = nil)
-          directive = command.fetch("tmux")
-          action = directive.fetch("action")
-          surface = control_surface_for(env: env)
-
-          case action
-          when "attach"
-            session = directive.fetch("session")
-            {shell_command: [tmux, "attach-session", "-t", session].map { |part| Shellwords.escape(part) }.join(" ")}
-          when "detach"
-            surface.detach_session(session: directive["session"])
-            nil
-          when "wait"
-            surface.wait_for_condition(
-              condition: directive.fetch("for"),
-              session: directive["session"],
-              window: directive["window"],
-              pane: directive["pane"],
-              pattern: directive["pattern"],
-              timeout: directive.fetch("timeout", Ace::Tmux::Organisms::ControlSurface::DEFAULT_TIMEOUT)
-            )
-            nil
-          when "send"
-            if directive["command"]
-              surface.send_command(
-                session: directive["session"],
-                window: directive["window"],
-                pane: directive["pane"],
-                command: directive["command"]
-              )
-            else
-              surface.send_key(
-                session: directive["session"],
-                window: directive["window"],
-                pane: directive["pane"],
-                key: directive.fetch("key")
-              )
-            end
-            nil
-          else
-            raise ArgumentError, "Unsupported tmux action '#{action}'"
-          end
-        rescue KeyError => e
-          raise ArgumentError, "Invalid tmux directive: missing #{e.key}"
-        rescue Ace::Tmux::Error => e
-          raise Ace::Demo::Error, e.message
-        end
-
-        private
-
-        attr_reader :control_surface, :executor, :tmux
-
-        def control_surface_for(env:)
-          return control_surface if control_surface
-
-          resolver = Ace::Tmux::Molecules::RuntimeTargetResolver.new(
-            executor: executor,
-            tmux: tmux,
-            env: env || ENV
-          )
-          Ace::Tmux::Organisms::ControlSurface.new(executor: executor, resolver: resolver, tmux: tmux)
-        end
-      end
-    end
-  end
-end