wslc-wip 0.13.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d7c6ca103234cf197e8ac46015705762a93febd37b57fd2b20fef283bfbf91c
-  data.tar.gz: 127f768a68ed87d54a72dcf8ea5ef9d6daeae5cecc0a6a2475b683f3bf2309c6
+  metadata.gz: 0c96178bbfe0be6dd82a52cc8cc7d3334688c97b981aaa7c35cfad5c0429c82b
+  data.tar.gz: f8574971724779ec668a41d9c1509aeab624222953dba34a609defd81b5c6589
 SHA512:
-  metadata.gz: 9261bab775ca93d1509886c2b94a19c5b2caeb422ca23a20652f9e23e49b247a05a9267043c163a26c9fffb50497cfbcbfde7acba7186222549414f95c1670cf
-  data.tar.gz: 6584d50a4d7199522a58f7dceb9b72d103b34b2b6d1a87c8a106ae85d4cefdf79c6870889936f521f7a6654afcf8e49d7a5262a47c7080ee919160fceffec56c
+  metadata.gz: 938472e7df5f8f97e5c5160ad299a1a83a1f1026c6320a00183944e3386ca80b323104aa0a101d27ec7694f752de7b502d963e38970d32e2b4040d0388acc1bf
+  data.tar.gz: d33a1ff1ff31dce4d8d6d6c9114ce3a0fa2da8ac29a2f89757114ab351d0b1de8a331071f50ebb2456443b38ebb4b315c88c635efd12d5982eb879d267c48434

data/README.md

@@ -295,11 +295,53 @@ found, its version, and which compose file `wip` resolved.
 - `commands:` entries with `type: run`/`type: build` aren't supported in compose mode — use your
   compose tool's own `build`/`up --build` directly; compose owns builds for its own services.
 
+### Compose mode (native)
+
+Don't want to install a third-party compose-for-`wslc` tool at all? `mode: compose-native` parses
+`compose.yml` itself and drives `wslc` directly, the same way `mode: container` +`dependencies:`
+already does — no external binary, and `wip run` gets a real ephemeral `wslc run --rm` instead of
+the `exec` fallback above:
+
+```yaml
+version: 1
+mode: compose-native
+
+compose:
+  service: app    # required: which compose service wip run/exec/NAME target
+  file: compose.yml # optional; auto-detected next to wip.yml otherwise
+  project: myapp    # optional; also names wip's own project network (defaults to the wip.yml
+                    # directory's name) so services can reach each other by name
+```
+
+There's no `compose.command` here (no external binary to name), and no top-level `container:` —
+`compose.service` already names it.
+
+This is explicitly a stopgap for as long as `wslc` itself has no native Compose support (tracked
+upstream in [microsoft/WSL#40948](https://github.com/microsoft/WSL/issues/40948)) and third-party
+compose-for-`wslc` tools stay incomplete. It only understands a minimal subset of the Compose spec.
+Within `services.<name>:`, anything outside that subset is a load-time `ConfigError` naming the
+offending key, rather than silently ignored — but everything *outside* `services:` at the document's
+top level (`networks:`, `volumes:`, `configs:`, `secrets:`, ...) is the one exception: it's read by
+real Compose tools, not by `wip`, so `wip` silently ignores it rather than rejecting an otherwise
+valid compose.yml over sections it doesn't need to look at:
+
+- Per service: `image`, `build` (string or `{context:, dockerfile:}`; resolved relative to
+  `compose.yml`, not wherever `wip` is invoked from), `command` (shell or exec form), `environment`
+  (mapping or `KEY=VALUE` array — a mapping value must not be null; host environment pass-through
+  isn't supported), `ports`/`volumes` (short syntax only — `"host:container"` strings, not
+  long-syntax mappings), `working_dir`, `depends_on` (ordering only — a `condition:` other than
+  `service_started` is rejected, since there's no health-check support).
+- `wip logs` takes at most one `SERVICE` (defaulting to `compose.service`) — `wslc logs`, like
+  `docker logs`, follows a single container, unlike a real compose tool's multi-service view.
+- `sync:` behaves exactly like `mode: container`'s (falls back to the primary service's own image,
+  defaults to `sync.mode: exec`) — none of the external bridge's `sync.image`/`sync.build`
+  requirement applies, since wip itself boots every container here.
+
 ## Commands
 
 | Command | Description |
 |---|---|
-| `wip init [--force]` | Write a starter `wip.yml`: `mode: compose` if a `compose.yml`/`docker-compose.yml` is found next to it, `mode: container` otherwise. Refuses to overwrite an existing `wip.yml` unless `--force` |
+| `wip init [--force]` | Write a starter `wip.yml`: `mode: compose-native` if a `compose.yml`/`docker-compose.yml` is found next to it, `mode: container` otherwise. Refuses to overwrite an existing `wip.yml` unless `--force` |
 | `wip version` | wip's version, plus WSLC's if it can be detected |
 | `wip doctor` | Diagnose WSL2, interop, WSLC, config, architecture, and Git |
 | `wip config` | Print the effective configuration (secrets masked) |
@@ -307,9 +349,9 @@ found, its version, and which compose file `wip` resolved.
 | `wip up [-d] [--no-sync]` | Start the primary `dependencies:` entry (`container:` names which one) and its sidecars (creating any that are missing, on `network:` if set). `-d` runs the main container in the background; with `sync:` configured, the source is mirrored into the volume first unless `--no-sync` |
 | `wip down` | Stop and remove the primary container and its sidecar `dependencies:` |
 | `wip exec [--no-interactive] COMMAND...` | Run a command in the existing container |
-| `wip run [--no-interactive] COMMAND...` | Run a command in a new `--rm` container (compose mode: `exec`s into `compose.service` instead) |
+| `wip run [--no-interactive] COMMAND...` | Run a command in a new `--rm` container (mode: compose `exec`s into `compose.service` instead — see "Compose mode" above) |
 | `wip shell` | Open the configured shell, falling back to `bash` then `sh` |
-| `wip logs [-f] [SERVICE...]` | Follow compose service logs (compose mode only) |
+| `wip logs [-f] [SERVICE...]` | Follow compose service logs (compose modes only; mode: compose-native takes at most one `SERVICE`) |
 | `wip sync [-w] [--interval N]` | Mirror the source into the sync volume once, or keep re-syncing with `--watch` (needs `sync:`) |
 | `wip NAME ARGS...` | Run `commands.NAME`, appending any extra arguments |
 
@@ -428,10 +470,11 @@ checklist.
 
 ## Not in the initial release
 
-Full Compose compatibility isn't reimplemented in `wip` itself, but is available by delegating to
-a third-party compose-for-`wslc` tool — see [Compose mode](#compose-mode). A resident/daemon
-process, a GUI, PowerShell-specific tuning, direct registry API/manifest parsing, self-update, and
-plugins are all unimplemented.
+Full Compose compatibility isn't reimplemented in `wip` itself — `mode: compose-native` only
+covers a minimal subset (see [Compose mode (native)](#compose-mode-native)), and full parity is
+otherwise available by delegating to a third-party compose-for-`wslc` tool (see
+[Compose mode](#compose-mode)). A resident/daemon process, a GUI, PowerShell-specific tuning,
+direct registry API/manifest parsing, self-update, and plugins are all unimplemented.
 
 ## Roadmap
 

data/lib/wip/cli.rb

@@ -48,7 +48,7 @@ module Wip
 
       initializer = Initializer.new(dir: path.dirname)
       path.write(initializer.call)
-      warn "wip: wrote #{path} (mode: #{initializer.compose? ? 'compose' : 'container'})"
+      warn "wip: wrote #{path} (mode: #{initializer.compose? ? 'compose-native' : 'container'})"
     end
 
     desc 'doctor', 'Diagnose the development environment'
@@ -82,6 +82,7 @@ module Wip
         return execute(compose_bridge.up(detach: options[:detach]), interactive: tty?(!options[:detach]))
       end
 
+      ensure_compose_images
       ensure_network
       sidecar_names.each { |name| ensure_dependency(name) }
       sync_before_boot if options[:sync]
@@ -155,9 +156,22 @@ module Wip
     desc 'logs [SERVICE...]', 'Follow logs from compose services (compose mode only)'
     option :follow, type: :boolean, default: true, aliases: '-f'
     def logs(*services)
-      raise ConfigError, '`wip logs` is only available in compose mode' unless load_config.compose?
+      unless load_config.compose? || load_config.compose_native?
+        raise ConfigError, '`wip logs` is only available in compose mode'
+      end
+      if load_config.compose?
+        return execute(compose_bridge.logs(services: services, follow: options[:follow]),
+                       interactive: true)
+      end
+
+      # wslc has no compose-style multi-service log aggregation (see CommandBuilder#logs) —
+      # exactly one SERVICE is required, defaulting to compose.service when none is given.
+      if services.size > 1
+        raise ConfigError, '`wip logs` under mode: compose-native takes at most one SERVICE ' \
+                           '(wslc logs, unlike a real compose tool, only follows one container at a time)'
+      end
 
-      execute(compose_bridge.logs(services: services, follow: options[:follow]), interactive: true)
+      execute(builder.logs(services.first || load_config.compose_service, follow: options[:follow]), interactive: true)
     end
 
     desc 'dispatch COMMAND [ARGS...]', 'Run a command defined in wip.yml'
@@ -272,6 +286,16 @@ module Wip
       load_config.sync || raise(ConfigError, '`wip sync` needs a sync: block in wip.yml')
     end
 
+    # Builds every compose-native service with a build: (instead of image:) once per
+    # `wip up` invocation, mirroring ensure_sync_image's "build once, not every tick"
+    # approach. A no-op for mode: container/compose and for build:-less services.
+    def ensure_compose_images
+      load_config.compose_build_specs.each_value do |spec|
+        extra = spec['dockerfile'] ? ['-f', spec['dockerfile']] : []
+        execute(builder.build(settings: { 'context' => spec['context'], 'tag' => spec['tag'] }, extra: extra))
+      end
+    end
+
     # Builds sync.build's image once per invocation (not per --watch tick, which
     # would pay Docker build-cache-lookup overhead on every mirror for no reason).
     # A no-op unless sync.build is configured.

data/lib/wip/command_builder.rb

@@ -88,6 +88,16 @@ module Wip
       [@wslc, 'stop', required_container]
     end
 
+    # Only reachable under mode: compose-native — mode: compose delegates `wip logs`
+    # to the external compose command's own `logs` (ComposeBridge#logs) instead.
+    # Single container only, mirroring `wslc`/docker's own `logs`: there's no
+    # multi-service log aggregation the way a real compose tool provides.
+    def logs(name, follow: true)
+      command = [@wslc, 'logs']
+      command << '-f' if follow
+      command.push(name.to_s)
+    end
+
     def remove
       [@wslc, 'remove', '-f', required_container]
     end

data/lib/wip/compose_file.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'pathname'
+require 'shellwords'
+
+module Wip
+  # Parses compose.yml/docker-compose.yml into the shape mode: compose-native
+  # needs to drive `wslc` directly, in place of an external compose-for-wslc
+  # binary (see ComposeBridge/mode: compose).
+  #
+  # This exists only because `wslc` has no native Compose support yet
+  # (tracked upstream in microsoft/WSL#40948). Delete this file — and its
+  # hooks in config.rb, cli.rb, doctor.rb and initializer.rb (see README
+  # "Compose mode (native)") — once wslc ships that support, or a
+  # compose-for-wslc tool reliably supports `run`.
+  class ComposeFile
+    Service = Struct.new(:image, :build, :command, :env, :ports, :volumes, :workdir, :depends_on, keyword_init: true)
+
+    SERVICE_KEYS = %w[image build command environment ports volumes working_dir depends_on].freeze
+    BUILD_KEYS = %w[context dockerfile].freeze
+    SUPPORTED_CONDITIONS = %w[service_started].freeze
+
+    def self.load(path)
+      raw = YAML.safe_load_file(path, aliases: true)
+      raise ConfigError, "#{path}: services: must be a mapping" unless raw.is_a?(Hash) && raw['services'].is_a?(Hash)
+
+      new(raw['services'], path: path)
+    rescue Psych::Exception => e
+      raise ConfigError, "Could not parse #{path}: #{e.message}"
+    rescue Errno::ENOENT
+      raise ConfigError, "Compose file not found: #{path}"
+    end
+
+    def initialize(services, path:)
+      @path = path
+      @services = services.to_h { |name, entry| [name.to_s, build_service(name.to_s, entry)] }
+      validate_depends_on!
+      @order = topological_order
+    end
+
+    def service_names_in_dependency_order = @order.dup
+
+    # name => {context:, dockerfile:, tag:} for every service with a build:.
+    def build_specs
+      @order.filter_map do |name|
+        build = @services.fetch(name).build
+        next unless build
+
+        [name, build.merge('tag' => image_tag(name))]
+      end.to_h
+    end
+
+    # Shaped like Config::DEPENDENCY_DEFAULTS expects: image/command/env/ports/volumes/workdir,
+    # in dependency order so callers iterating sidecars start them before their dependents.
+    def to_dependencies_hash
+      @order.to_h do |name|
+        service = @services.fetch(name)
+        [name, { 'image' => service.build ? image_tag(name) : service.image, 'command' => service.command,
+                 'env' => service.env, 'ports' => service.ports, 'volumes' => service.volumes,
+                 'workdir' => service.workdir }]
+      end
+    end
+
+    private
+
+    def image_tag(name) = "wip-compose-#{name}:latest"
+
+    def build_service(name, entry)
+      raise ConfigError, "#{@path}: services.#{name} must be a mapping" unless entry.is_a?(Hash)
+
+      unknown = entry.keys.map(&:to_s) - SERVICE_KEYS
+      raise ConfigError, "#{@path}: services.#{name} has unsupported key(s): #{unknown.join(', ')}" if unknown.any?
+
+      image, build = image_or_build(name, entry)
+      Service.new(image: image, build: build, command: normalize_command(entry['command']),
+                  env: normalize_env(name, entry['environment']),
+                  ports: normalize_list(name, entry['ports'], 'ports'),
+                  volumes: normalize_list(name, entry['volumes'], 'volumes'),
+                  workdir: presence(entry['working_dir']), depends_on: normalize_depends_on(name, entry['depends_on']))
+    end
+
+    def image_or_build(name, entry)
+      image = presence(entry['image'])
+      build = normalize_build(name, entry['build'])
+      raise ConfigError, "#{@path}: services.#{name} must set image or build" unless image || build
+      raise ConfigError, "#{@path}: services.#{name} must not set both image and build" if image && build
+
+      [image, build]
+    end
+
+    # Compose allows both shell form ("bin/rails s") and exec form (["bin/rails", "s"]);
+    # CommandBuilder re-splits whatever's here with Shellwords, so join exec form back into
+    # one string instead of letting Array#to_s (via presence) turn it into a literal
+    # "[\"bin/rails\", \"s\"]" that Shellwords would then split wrong.
+    def normalize_command(value)
+      return presence(value) unless value.is_a?(Array)
+
+      presence(Shellwords.join(value.map(&:to_s)))
+    end
+
+    def normalize_build(name, value)
+      return nil unless value
+
+      case value
+      when String then { 'context' => resolve_context(value) }
+      when Hash then normalize_build_mapping(name, value)
+      else raise ConfigError, "#{@path}: services.#{name}.build must be a string or mapping"
+      end
+    end
+
+    def normalize_build_mapping(name, value)
+      unknown = value.keys.map(&:to_s) - BUILD_KEYS
+      if unknown.any?
+        raise ConfigError,
+              "#{@path}: services.#{name}.build has unsupported key(s): #{unknown.join(', ')}"
+      end
+
+      context = resolve_context(presence(value['context']) || '.')
+      dockerfile = presence(value['dockerfile'])
+      { 'context' => context, 'dockerfile' => dockerfile && Pathname(context).join(dockerfile).to_s }.compact
+    end
+
+    # build.context is relative to compose.yml's own directory (Compose's own rule),
+    # not wherever `wip` happens to be invoked from.
+    def resolve_context(raw) = Pathname(@path).expand_path.dirname.join(raw).to_s
+
+    def normalize_env(name, value)
+      return {} unless value
+
+      case value
+      when Hash then normalize_env_mapping(name, value)
+      when Array then normalize_env_array(name, value)
+      else raise ConfigError, "#{@path}: services.#{name}.environment must be a mapping or an array of KEY=VALUE"
+      end
+    end
+
+    def normalize_env_mapping(name, value)
+      value.to_h do |key, val|
+        if val.nil?
+          raise ConfigError, "#{@path}: services.#{name}.environment.#{key} must have a value " \
+                             '(host environment pass-through is not supported)'
+        end
+
+        [key.to_s, val.to_s]
+      end
+    end
+
+    def normalize_env_array(name, value)
+      value.to_h do |item|
+        key, val = item.to_s.split('=', 2)
+        raise ConfigError, "#{@path}: services.#{name}.environment entries must be KEY=VALUE" unless val
+
+        [key, val]
+      end
+    end
+
+    def normalize_list(name, value, key)
+      return [] unless value
+      raise ConfigError, "#{@path}: services.#{name}.#{key} must be an array" unless value.is_a?(Array)
+      if value.any?(Hash)
+        raise ConfigError, "#{@path}: services.#{name}.#{key} only supports short syntax (\"host:container\"), " \
+                           'not long-syntax mappings'
+      end
+
+      value.map(&:to_s)
+    end
+
+    def normalize_depends_on(name, value)
+      return [] unless value
+
+      case value
+      when Array then value.map(&:to_s)
+      when Hash then value.map { |dep, opts| depends_on_entry(name, dep, opts) }
+      else raise ConfigError, "#{@path}: services.#{name}.depends_on must be an array or a mapping"
+      end
+    end
+
+    def depends_on_entry(name, dep, opts)
+      condition = opts.is_a?(Hash) ? opts['condition'] : nil
+      if condition && !SUPPORTED_CONDITIONS.include?(condition)
+        raise ConfigError, "#{@path}: services.#{name}.depends_on.#{dep}: condition '#{condition}' is not " \
+                           "supported (only #{SUPPORTED_CONDITIONS.join(', ')} — no health checks)"
+      end
+      dep.to_s
+    end
+
+    def validate_depends_on!
+      @services.each do |name, service|
+        service.depends_on.each do |dep|
+          raise ConfigError, "#{@path}: services.#{name} depends_on unknown service '#{dep}'" unless @services.key?(dep)
+        end
+      end
+    end
+
+    def topological_order
+      visited = {}
+      visiting = {}
+      order = []
+      @services.each_key { |name| visit(name, visited, visiting, order) }
+      order
+    end
+
+    def visit(name, visited, visiting, order)
+      return if visited[name]
+      raise ConfigError, "#{@path}: services.#{name} is part of a depends_on cycle" if visiting[name]
+
+      visiting[name] = true
+      @services.fetch(name).depends_on.each { |dep| visit(dep, visited, visiting, order) }
+      visiting.delete(name)
+      visited[name] = true
+      order << name
+    end
+
+    def presence(value) = value.to_s.empty? ? nil : value.to_s
+  end
+end

data/lib/wip/config.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'pathname'
+
 module Wip
   # Validated, defaulted access to a parsed wip.yml document.
   class Config
@@ -11,7 +13,10 @@ module Wip
     # Which orchestration path `up`/`down`/`sync`/etc. take. Explicit rather than
     # inferred from a `compose:` block's presence, so a config reader doesn't have
     # to know that rule to predict which mode wip runs in.
-    MODES = %w[container compose].freeze
+    # compose bridges to an external compose-for-wslc binary (ComposeBridge);
+    # compose-native parses compose.yml itself and drives wslc directly (ComposeFile) —
+    # a stopgap for as long as those external tools stay incomplete (missing `run`, etc.).
+    MODES = %w[container compose compose-native].freeze
     attr_reader :path
 
     def initialize(raw, path = nil)
@@ -22,22 +27,37 @@ module Wip
 
     def wslc_command = @raw.dig('wslc', 'command') || 'auto'
     def commands = @raw['commands'] || {}
-    def dependencies = @raw['dependencies'] || {}
+    # Raw dependencies: block as written in wip.yml. Under compose-native mode this stays
+    # empty by construction (validate_compose! forbids combining the two) — #dependencies
+    # below is what callers actually want, since it's synthesized from compose.yml there.
+    def raw_dependencies = @raw['dependencies'] || {}
+    def dependencies = compose_native? ? parsed_compose_file.to_dependencies_hash : raw_dependencies
     # Which dependencies: entry `up`/`down`/`exec`/`run`/`build`/`commands:` target
     # by default — the one container wip itself considers "the app." Everything
     # else in dependencies: is a sidecar wip only starts and stops. No default:
     # guessing a name here (the old default was "app") either matches by luck or
     # fails in a way that doesn't point at the real problem (a differently-named
     # entry), so a project with any dependencies: must say which one explicitly.
-    def container = presence(@raw['container'])
-    def network = @raw['network']
+    # Under compose-native mode, container: is compose.service — compose.yml already
+    # names the service, so there's no separate container: key to set in wip.yml.
+    def container = compose_native? ? compose_service : presence(@raw['container'])
+    # Under compose-native mode, wip creates its own project network (compose.project,
+    # or the wip.yml directory's name) so services can reach each other by name — the
+    # same guarantee real Compose's per-project network gives.
+    def network = compose_native? ? (compose_project || default_compose_network) : @raw['network']
     def mode = @raw['mode'] || 'container'
     def compose = @raw['compose']
     def compose? = mode == 'compose'
+    def compose_native? = mode == 'compose-native'
+    def compose_mode? = compose? || compose_native?
     def compose_service = compose && compose['service']
     def compose_file = compose && compose['file']
     def compose_project = compose && compose['project']
     def compose_command = compose && compose['command']
+    # name => {context:, dockerfile:, tag:} for compose-native services with a build:
+    # instead of an image: — empty otherwise. Consumed by `wip up` to build each one
+    # before starting it (see CommandBuilder#build).
+    def compose_build_specs = compose_native? ? parsed_compose_file.build_specs : {}
     def sync? = !!sync
 
     def sync
@@ -92,8 +112,10 @@ module Wip
 
     def validate_mode!
       raise ConfigError, "mode must be one of #{MODES.join(', ')}" unless MODES.include?(mode)
-      raise ConfigError, 'mode: compose requires a compose: block' if compose? && !@raw.key?('compose')
-      raise ConfigError, 'a compose: block requires mode: compose' if @raw.key?('compose') && !compose?
+      raise ConfigError, "mode: #{mode} requires a compose: block" if compose_mode? && !@raw.key?('compose')
+      return unless @raw.key?('compose') && !compose_mode?
+
+      raise ConfigError, 'a compose: block requires mode: compose or compose-native'
     end
 
     # Forces SyncSettings to build (and so run its own validation, including
@@ -109,25 +131,41 @@ module Wip
     end
 
     def validate_dependencies!
-      raise ConfigError, 'dependencies must be a mapping' unless dependencies.is_a?(Hash)
-      # Under compose mode, populated dependencies: is already an error on its own
-      # (validate_compose!, below) — this only needs to fire for the mode: container
+      raise ConfigError, 'dependencies must be a mapping' unless raw_dependencies.is_a?(Hash)
+      # Under either compose mode, populated dependencies: is already an error on its
+      # own (validate_compose!, below) — this only needs to fire for the mode: container
       # case, where dependencies: having entries but no container: is otherwise valid.
-      if dependencies.any? && !container && !compose?
+      if raw_dependencies.any? && !container && !compose_mode?
         raise ConfigError,
               'container: must be set when dependencies: has entries'
       end
 
-      dependencies.each { |name, entry| validate_dependency!(name, entry) }
+      raw_dependencies.each { |name, entry| validate_dependency!(name, entry) }
     end
 
     def validate_compose!
       return unless @raw.key?('compose')
       raise ConfigError, 'compose must be a mapping' unless compose.is_a?(Hash)
       raise ConfigError, 'compose.service must not be empty' if compose_service.to_s.empty?
-      raise ConfigError, 'compose.command must not be empty' if compose_command.to_s.empty?
-      raise ConfigError, 'compose is mutually exclusive with dependencies' if dependencies.any?
-      raise ConfigError, 'compose is mutually exclusive with network' if network
+      raise ConfigError, 'compose is mutually exclusive with dependencies' if raw_dependencies.any?
+      raise ConfigError, 'compose is mutually exclusive with network' if @raw['network']
+
+      validate_compose_command!
+    end
+
+    # compose.command has opposite requiredness depending on which compose mode this
+    # is: mode: compose has no default (every external compose-for-wslc implementation
+    # must be named explicitly), while mode: compose-native drives wslc directly and so
+    # has no external binary to name at all.
+    def validate_compose_command!
+      if compose_native?
+        if compose_command
+          raise ConfigError, 'compose.command is not used under mode: compose-native (wip drives wslc ' \
+                             'directly — there’s no external compose binary to name)'
+        end
+      elsif compose_command.to_s.empty?
+        raise ConfigError, 'compose.command must not be empty'
+      end
     end
 
     def validate_command!(name, entry)
@@ -162,5 +200,11 @@ module Wip
     end
 
     def presence(value) = value.to_s.empty? ? nil : value.to_s
+
+    def parsed_compose_file
+      @parsed_compose_file ||= ComposeFile.load(ComposeBridge.file_path(self))
+    end
+
+    def default_compose_network = path && Pathname(path).dirname.basename.to_s
   end
 end

data/lib/wip/doctor.rb

@@ -51,9 +51,15 @@ module Wip
 
     # dependencies.<container> having an empty image is already a load-time
     # ConfigError (validate_dependency!), so the only way to reach here with a
-    # broken primary container is `container:` naming an entry that isn't defined.
+    # broken primary container is `container:` naming an entry that isn't defined
+    # — or, under compose-native, compose.service naming a service compose.yml
+    # doesn't actually define.
     def container_result(config)
       return [:ok, 'Loaded wip.yml'] if config.compose? || config.primary
+      if config.compose_native?
+        return [:fail,
+                "compose.service '#{config.container}' has no matching service in compose.yml"]
+      end
 
       [:fail, "No dependencies.#{config.container} entry"]
     end
@@ -63,6 +69,7 @@ module Wip
 
       check_wslc(config, results)
       check_compose(config, results) if config.compose?
+      check_compose_native(config, results) if config.compose_native?
       check_sync(config, results) if config.sync?
     end
 
@@ -103,10 +110,25 @@ module Wip
       nil
     end
 
+    # Returns whether the file was found, so check_compose_native can skip
+    # attempting to parse a file that's already been reported missing.
     def check_compose_file(config, results)
       path = ComposeBridge.file_path(config)
-      results << result(path.file? ? :ok : :fail, "Found compose file #{path}",
-                        "Compose file not found: #{path}")
+      found = path.file?
+      results << result(found ? :ok : :fail, "Found compose file #{path}", "Compose file not found: #{path}")
+      found
+    rescue ConfigError => e
+      results << Result.new(:fail, e.message)
+      false
+    end
+
+    # mode: compose-native has no external binary to check (check_wslc, above, already
+    # covers the one binary it drives) — just that compose.yml exists and parses.
+    def check_compose_native(config, results)
+      return unless check_compose_file(config, results)
+
+      ComposeFile.load(ComposeBridge.file_path(config))
+      results << Result.new(:ok, 'Parsed compose file')
     rescue ConfigError => e
       results << Result.new(:fail, e.message)
     end

data/lib/wip/initializer.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module Wip
   # Builds a starter wip.yml. Detects an existing compose file next to the
   # target (the same filenames ComposeBridge auto-detects) to decide between
-  # mode: compose and mode: container, since that's the one decision `wip
-  # init` can't leave to a placeholder.
+  # mode: compose-native and mode: container, since that's the one decision
+  # `wip init` can't leave to a placeholder.
   class Initializer
     CONTAINER_TEMPLATE = <<~YAML
       version: 1
@@ -40,56 +38,15 @@ module Wip
     def compose_template
       <<~YAML
         version: 1
-        mode: compose
-        container: app # TODO: rename freely; only used to name sync's volume ("<container>-src"),
-                        # since compose.yml — not dependencies: — owns this service's own definition
+        mode: compose-native # wip parses #{compose_file} itself and drives wslc directly — no external
+                              # compose-for-wslc binary needed. Prefer a real compose tool instead? Use
+                              # mode: compose (see README "Compose mode") and set compose.command.
 
         compose:
           service: app # TODO: which service in #{compose_file} wip run/exec/NAME target
-          command: wslc-compose # TODO: the compose-for-wslc binary/path you have installed
 
-        #{sync_hint}
+        sync: {} # optional; mirrors the source into a named volume instead of bind-mounting it live
       YAML
     end
-
-    # sync: needs sync.image or sync.build (mode: compose has no dependencies: entry to borrow an
-    # image from) and a named volume the compose service mounts, matching sync.volume ("app-src" by
-    # default). Checked against the detected compose file so the hint doesn't repeat what's set up.
-    def sync_hint
-      return sync_hint_configured if compose_volume_mounted?
-
-      sync_hint_todo
-    end
-
-    def sync_hint_configured
-      <<~COMMENT.chomp
-        # #{compose_file} already mounts a volume matching sync.volume's default (app-src).
-        # sync: # add sync.build or sync.image too (one's required under mode: compose) — see README
-      COMMENT
-    end
-
-    def sync_hint_todo
-      <<~COMMENT.chomp
-        # sync: # optional; mirrors the source into a named volume instead of bind-mounting it live
-        #   build: # required under mode: compose (no dependencies: entry to borrow an image from)
-        #     dockerfile: |
-        #       FROM alpine:latest
-        #       RUN apk add --no-cache rsync
-        #   # the service above must also mount a volume named "app-src" (sync.volume's default) at the
-        #   # path your app expects — add to #{compose_file}:
-        #   #   volumes:
-        #   #     - app-src:/app
-        #   # and, alongside services:
-        #   # volumes:
-        #   #   app-src:
-      COMMENT
-    end
-
-    def compose_volume_mounted?
-      services = YAML.safe_load_file(File.join(@dir, compose_file), aliases: true)&.fetch('services', nil) || {}
-      services.values.any? { |service| Array(service['volumes']).any? { |v| v.to_s.start_with?('app-src:') } }
-    rescue StandardError
-      false
-    end
   end
 end

data/lib/wip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wip
-  VERSION = '0.13.1'
+  VERSION = '0.14.0'
 end

data/lib/wip.rb

@@ -13,6 +13,7 @@ require_relative 'wip/command_resolver'
 require_relative 'wip/error_interpreter'
 require_relative 'wip/command_builder'
 require_relative 'wip/compose_bridge'
+require_relative 'wip/compose_file'
 require_relative 'wip/initializer'
 require_relative 'wip/command_display'
 require_relative 'wip/command_runner'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wslc-wip
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.14.0
 platform: ruby
 authors:
 - Wip contributors
@@ -40,6 +40,7 @@ files:
 - lib/wip/command_resolver.rb
 - lib/wip/command_runner.rb
 - lib/wip/compose_bridge.rb
+- lib/wip/compose_file.rb
 - lib/wip/config.rb
 - lib/wip/config_loader.rb
 - lib/wip/debug_reporter.rb