ask-local 0.1.0 → 0.2.0

data/lib/ask/local/cli/routes.rb

@@ -19,13 +19,11 @@ module Ask
           raise Error, "Usage: ask-local get <name> [--service s] [--variant v] [--tld t]" unless name
 
           opts = ctx.parse_flags(args[1..] || [], %i[service variant tld])
-          context = Resolver.resolve(Dir.pwd, service: opts[:service],
-            variant: opts[:variant], tlds: opts[:tld], use_branch: false)
+          context = Resolver.resolve(Dir.pwd, variant: opts[:variant])
           hostnames = Hostname.build(
             app: Sanitize.hostname_label(name),
-            service: context.service,
-            variant: context.variant,
-            tlds: context.tlds
+            tlds: Array(context.tld || Ask::Local::Hostname::DEFAULT_TLD),
+            variant: context.variant
           )
           puts Hostname.url(hostnames.first, port: ctx.proxy_port, tls: ctx.proxy_tls)
         end
@@ -206,9 +204,11 @@ module Ask
           end
           payload = {
             app: resolved.app, app_source: resolved.sources[:app],
-            service: resolved.service, service_source: resolved.sources[:service],
+            tld: resolved.tld, tld_source: resolved.sources[:tld],
+            host: resolved.host, host_source: resolved.sources[:host],
             variant: resolved.variant, variant_source: resolved.sources[:variant],
-            tlds: resolved.tlds, urls: urls,
+            urls: urls,
+            processes: resolved.processes.keys,
             framework: Framework.detect(Dir.pwd).to_s
           }
           if json
@@ -217,9 +217,13 @@ module Ask
             return
           end
           puts "app:       #{payload[:app]} (from #{payload[:app_source]})"
-          puts "service:   #{payload[:service] || "web (default, bare)"} (from #{payload[:service_source] || "default"})"
-          puts "variant:   #{payload[:variant] || "(none)"} (from #{payload[:variant_source] || "no worktree, branch, flag, or env"})"
-          puts "tlds:      #{payload[:tlds].join(", ")}"
+          if payload[:host]
+            puts "host:      #{payload[:host]} (from #{payload[:host_source]})"
+          else
+            puts "tld:       #{payload[:tld]} (from #{payload[:tld_source]})"
+          end
+          puts "variant:   #{payload[:variant] || "(none)"} (from #{payload[:variant_source] || "no overlay file, flag, or env"})"
+          puts "processes: #{payload[:processes].join(", ")}"
           puts "urls:"
           urls.each { |u| puts "  #{u}" }
           puts "framework: #{payload[:framework]}"
@@ -231,10 +235,10 @@ module Ask
           url =
             if name
               opts = ctx.parse_flags(args[1..] || [], %i[service variant tld])
-              context = Resolver.resolve(Dir.pwd, service: opts[:service],
-                variant: opts[:variant], tlds: opts[:tld], use_branch: false)
+              context = Resolver.resolve(Dir.pwd, variant: opts[:variant], tld: opts[:tld])
               hostnames = Hostname.build(app: Sanitize.hostname_label(name),
-                service: context.service, variant: context.variant, tlds: context.tlds)
+                tlds: Array(context.tld || Ask::Local::Hostname::DEFAULT_TLD),
+                variant: context.variant)
               Hostname.url(hostnames.first, port: ctx.proxy_port, tls: ctx.proxy_tls)
             else
               resolved = Resolver.resolve(Dir.pwd)

data/lib/ask/local/cli/system.rb

@@ -263,6 +263,273 @@ module Ask
           end
         end
 
+
+        def init(ctx, _args)
+          config_path = File.join(Dir.pwd, Config::RELATIVE_PATH)
+          if File.file?(config_path)
+            $stderr.puts "config/local.yml already exists at #{config_path}"
+            return
+          end
+          FileUtils.mkdir_p(File.join(Dir.pwd, Config::RELATIVE_DIR))
+
+          # Migrate Procfile.dev / Procfile if present.
+          procfile = Ask::Local::Procfile.find_file(Dir.pwd)
+          service = Ask::Local::Sanitize.hostname_label(File.basename(Dir.pwd))
+
+          process_lines = []
+          if procfile
+            lines = Ask::Local::Procfile.parse_file(procfile)
+            lines.each do |l|
+              type = Ask::Local::Procfile.classify(l.name) == :background ? "false" : "true"
+              process_lines << "    #{l.name}:"
+              process_lines << "      cmd: #{l.command}"
+              process_lines << "      proxy: #{type}"
+              process_lines << "      # NOTE: compound line - run explicitly" if l.compound
+            end
+          else
+            # Default: a single web process. Detect Rails (Gemfile with
+            # rails) vs plain Rack (config.ru) and pick the right boot.
+            has_rails = File.file?(File.join(Dir.pwd, "Gemfile")) &&
+              File.read(File.join(Dir.pwd, "Gemfile")).match?(/gem ["']rails["']/)
+            cmd =
+              if has_rails
+                "bundle exec puma -b tcp://127.0.0.1:$PORT config.ru"
+              elsif File.file?(File.join(Dir.pwd, "config.ru"))
+                "puma -b tcp://127.0.0.1:$PORT config.ru"
+              else
+                "bin/rails server -p $PORT"
+              end
+            process_lines << "    web:"
+            process_lines << "      cmd: #{cmd}"
+            process_lines << "      proxy: true"
+          end
+
+          content = <<~YAML
+            # config/local.yml — ask-local configuration (Kamal-style).
+            # This is the only source of truth. Run `ask-local` to boot everything.
+            # Overlay variants with config/local.<variant>.yml.
+
+            service: #{service}
+
+            proxy:
+              tld: localhost
+
+            processes:
+          #{process_lines.join("\n")}
+
+            env:
+              clear:
+                RAILS_ENV: development
+          YAML
+          File.write(config_path, content)
+          puts "Created #{config_path}"
+          puts "  service: #{service}"
+          puts "  processes from: #{procfile || 'defaults'}"
+          puts "Run `ask-local start` to boot."
+        end
+
+
+        def setup(ctx, args)
+          if args.include?("--help") || args.include?("-h")
+            puts <<~HELP
+              Usage: ask-local setup [--no-service]
+
+              One-shot workstation setup for clean https://<app>.localhost URLs:
+
+                1. Trust the local CA (no more browser warnings)
+                2. Serve port 443 (root service at boot, or sudo daemon now)
+                3. Sync /etc/hosts (Safari + custom TLDs)
+                4. Verify everything with doctor
+
+              --no-service skips the root service and starts a sudo daemon
+              instead (no boot persistence; good for ephemeral machines).
+            HELP
+            return
+          end
+
+          step("1/4 Trusting local CA") do
+            result = Ask::Local::Trust.trust
+            unless result[:trusted]
+              abort_setup("CA trust failed: #{result[:error]}",
+                "Run `ask-local trust` manually to see the underlying error,",
+                "then re-run `ask-local setup`.")
+            end
+          end
+
+          unless args.include?("--no-service")
+            step("2/4 Installing proxy service on port 443") do
+              unless ensure_root_service(ctx)
+                abort_setup("Could not install the proxy service.",
+                  "Fallback: `ask-local setup --no-service` for a sudo daemon",
+                  "without boot persistence.")
+              end
+            end
+          else
+            step("2/4 Starting proxy sudo daemon on port 443") do
+              unless ensure_sudo_daemon(ctx)
+                abort_setup("Could not start the proxy daemon on port 443.",
+                  "Check the log, then re-run `ask-local setup`.")
+              end
+            end
+          end
+
+          step("3/4 Syncing /etc/hosts") do
+            hostnames = ctx.store.load_routes.map { |r| r["hostname"] }
+            unless Ask::Local::Hosts.sync(hostnames)
+              abort_setup("Could not write /etc/hosts.",
+                "Run `sudo ask-local hosts sync`, then re-run `ask-local setup`.")
+            end
+          end
+
+          step("4/4 Verifying with doctor") do
+            failed = Doctor.print(Doctor.run(store: ctx.store), out: $stdout)
+            if failed.zero?
+              puts "\nSetup complete: https://<app>.localhost URLs are ready."
+              puts "Try it: cd ~/code/myapp && ask-local"
+            else
+              abort_setup("Doctor reports #{failed} failing check(s) (see above).",
+                "Fix the reported issues, then re-run `ask-local setup`.")
+            end
+          end
+        end
+
+        def step(label)
+          puts "\n==> #{label}..."
+          yield
+          puts "    ok"
+        end
+
+        def abort_setup(problem, *fixes)
+          $stderr.puts "\nSetup failed: #{problem}"
+          fixes.each { |f| $stderr.puts "  #{f}" }
+          exit 1
+        end
+
+        # Install the root service (boot-persistent). Returns true when a
+        # proxy is up on 443 afterwards, false otherwise. Never falls back
+        # to a high port silently: a :port suffix in URLs would corrupt the
+        # stable-URL promise, so failure here is a hard error with guidance.
+        def ensure_root_service(ctx)
+          service_install(ctx, [])
+          wait_for_ours(ctx, 443, tls: true)
+        rescue Error, SystemCallError => e
+          warn "    service install failed: #{e.message}"
+          false
+        end
+
+        # Sudo daemon for 443 without boot persistence (--no-service).
+        def ensure_sudo_daemon(ctx)
+          port, tls = 443, true
+          unless ctx.interactive?
+            warn "    no TTY available for the sudo prompt."
+            return false
+          end
+          ProxyControl.spawn_daemon(store: ctx.store, port: port, tls: tls, sudo: true)
+          wait_for_ours(ctx, port, tls: tls)
+        rescue Ask::Local::ProxyNotRunningError, SystemCallError => e
+          warn "    daemon start failed: #{e.message.lines.first&.strip}"
+          false
+        end
+
+        def wait_for_ours(ctx, port, tls:, timeout: 20)
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+          until ProxyControl.ours?(port, tls: tls)
+            return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+
+            sleep 0.5
+          end
+          true
+        end
+
+        # ask-local start — one-setup-and-go: idempotent workstation setup
+        # (trust, 443, hosts) when doctor fails, then boots the app in the
+        # current directory. The single command you run day-to-day; existing
+        # bare `ask-local` keeps working via BootCommand.run_inferred, and
+        # `setup` stays for explicit re-setup.
+        def start(ctx, args)
+          if args.include?("--help") || args.include?("-h")
+            puts <<~HELP
+              Usage: ask-local start [name] [cmd...] [options]
+
+              One-setup-and-go: if the workstation isn't ready (CA, proxy,
+              hosts), runs the minimal needed setup first, then boots the
+              app in the current directory.
+
+                ask-local start              # infer name, boot -> https://<app>.localhost
+                ask-local start myapp       # explicit name
+                ask-local start -- --help   # pass --help to the app, not here
+
+              Options are passed through to the boot path:
+                --name <name> --service <svc> --variant <v> --tld <tld> --branch
+
+              Setup failures become hard errors pointing at `ask-local setup`;
+              non-interactive CI without a running proxy exits immediately.
+            HELP
+            return
+          end
+
+          # Fast path: every doctor check passes => skip setup entirely.
+          # This makes `start` as fast as `ask-local` on a ready machine.
+          if needs_workstation_setup?(ctx)
+            ensure_workstation!(ctx)
+          end
+          BootCommand.run_inferred(ctx, args)
+        end
+
+        def needs_workstation_setup?(ctx)
+          Ask::Local::Doctor.run(store: ctx.store).any? { |c| !c.ok }
+        end
+
+
+        # Quiet workstation setup for `start`: trust the CA, ensure a proxy
+        # on 443 (root service, sudo daemon fallback), and sync hosts.
+        # Each step is idempotent; only missing pieces run. Non-interactive
+        # CI without a proxy fails fast rather than prompting for sudo.
+        def ensure_workstation!(ctx)
+          # 1. CA
+          unless Ask::Local::Certs.trusted?(ctx.store.dir)
+            result = Ask::Local::Trust.trust
+            unless result[:trusted]
+              abort_setup("CA trust failed: #{result[:error]}",
+                "Run `ask-local setup` in a terminal (handles trust + service),",
+                "then re-run `ask-local start`.")
+            end
+          end
+
+          # 2. Proxy on 443
+          port = 443
+          tls = true
+          unless Ask::Local::ProxyControl.listening?(port) && ProxyControl.ours?(port, tls: tls)
+            if port < 1024 && !Ask::Local::ProxyControl.root? && !ctx.interactive?
+              abort_setup("Proxy is not running and port 443 needs root to bind.",
+                "Run this once in a terminal: ask-local setup")
+            end
+            ok =
+              if ProxyControl.root?
+                Ask::Local::CLI::SystemCommand.ensure_root_service(ctx)
+              elsif ctx.interactive?
+                begin
+                  Ask::Local::ProxyControl.spawn_daemon(store: ctx.store, port: port, tls: tls, sudo: true)
+                  wait_for_ours(ctx, port, tls: tls)
+                rescue Ask::Local::ProxyNotRunningError, SystemCallError => e
+                  warn "    daemon start failed: #{e.message.lines.first&.strip}"
+                  false
+                end
+              else
+                false
+              end
+            unless ok
+              abort_setup("Proxy is not running and could not be started on port 443.",
+                "Run `ask-local setup` in a terminal (it handles trust + service + hosts),",
+                "then re-run `ask-local start`.")
+            end
+          end
+
+          # 3. Hosts (best-effort: only needed for Safari; warn, don't fail)
+          unless Hosts.sync(ctx.store.load_routes.map { |r| r["hostname"] })
+            warn "Warning: could not write /etc/hosts (try sudo ask-local hosts sync)."
+          end
+        end
         # ask-local kamal <variant> [--app myapp] [--domain preview.example.com]
         def kamal(_ctx, args)
           opts = {}
@@ -273,13 +540,15 @@ module Ask
             case a[i]
             when "--app" then opts[:app] = a.fetch(i + 1); i += 2
             when "--domain" then opts[:domain] = a.fetch(i + 1); i += 2
+            when "--tld" then opts[:tld] = a.fetch(i + 1); i += 2
             else rest << a[i]; i += 1
             end
           end
           variant = rest.first
-          raise Error, "Usage: ask-local kamal <variant> [--app myapp] [--domain preview.example.com]" unless variant
+          raise Error, "Usage: ask-local kamal <variant> [--app myapp] [--domain preview.example.com] [--tld <tld>]" unless variant
+          tld = opts[:tld] || ENV["ASK_LOCAL_TLD"]&.split(",")&.first || "localhost"
 
-          app = opts[:app] || Resolver.resolve(Dir.pwd, use_branch: false).app
+          app = opts[:app] || Resolver.resolve(Dir.pwd).app
           domain = opts[:domain] || ENV["ASK_LOCAL_KAMAL_DOMAIN"] || "preview.example.com"
           slug = Sanitize.hostname_label(variant)
           puts "# Paste into deploy.yml proxy section for a preview of variant #{slug}:"
@@ -287,6 +556,7 @@ module Ask
           puts "  ssl: true"
           puts "  hosts:"
           puts "    - #{app}-#{slug}.#{domain}"
+          puts "  # Prefer Kamal multi-host for production; single-host preview above is fine for ephemeral branches."
         end
       end
     end

data/lib/ask/local/cli.rb

@@ -11,7 +11,7 @@ module Ask
     # In non-interactive environments (no TTY or CI=1) we fail early with
     # a clear message instead of prompting (portless lesson).
     class CLI
-      SUBCOMMANDS = %w[run get alias hosts list doctor trust clean prune proxy service kamal stop restart log status open].freeze
+      SUBCOMMANDS = %w[run get alias hosts list doctor trust clean prune proxy service kamal stop restart log status open setup start init].freeze
 
       def self.run(argv)
         new.run(argv)
@@ -44,6 +44,9 @@ module Ask
         when "prune" then RoutesCommand.prune(ctx, args)
         when "proxy" then SystemCommand.proxy(ctx, args)
         when "service" then SystemCommand.service(ctx, args)
+        when "setup" then SystemCommand.setup(ctx, args)
+        when "init" then SystemCommand.init(ctx, args)
+        when "start" then SystemCommand.start(ctx, args)
         when "kamal" then SystemCommand.kamal(ctx, args)
         when "stop"
           exit RoutesCommand.stop(ctx, args)
@@ -64,7 +67,9 @@ module Ask
           ask-local - Stable named .localhost URLs for Ruby development.
 
           Usage:
-            ask-local                        Infer name, boot app -> https://<app>.localhost
+            ask-local start [name] [cmd...]  One-setup-and-go: setup if needed, then boot -> https://<app>.localhost
+            ask-local setup                One-shot workstation setup without booting (run once)
+            ask-local                        Bare form of `start` -> https://<app>.localhost
             ask-local run [cmd]              Same, with explicit command
             ask-local <name> <cmd>           Run with explicit name
             ask-local get <name>             Print URL for a service
@@ -95,7 +100,6 @@ module Ask
       def inject_port_flags(command, port)
         BootCommand.inject_port_flags(command, port)
       end
-
       def procfile_command(process = nil)
         BootCommand.procfile_command(process)
       end