ask-local 0.1.0

data/lib/ask/local/framework.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ask
+  module Local
+    # Detect what kind of Ruby app lives in a directory so the runner
+    # knows how to boot it. Pure filesystem convention, no shell-outs.
+    module Framework
+      RAILS = :rails
+      RACK = :rack
+      JEKYLL = :jekyll
+      BRIDGETOWN = :bridgetown
+      MIDDLEMAN = :middleman
+      PROCFILE = :procfile
+      UNKNOWN = :unknown
+
+      STATIC_GENERATORS = [JEKYLL, BRIDGETOWN, MIDDLEMAN].freeze
+
+      module_function
+
+      def detect(dir = Dir.pwd)
+        path = Pathname.new(File.expand_path(dir))
+        return RAILS if rails?(path)
+        return JEKYLL if jekyll?(path)
+        return BRIDGETOWN if bridgetown?(path)
+        return MIDDLEMAN if middleman?(path)
+        return RACK if rack?(path)
+        return PROCFILE if procfile?(path)
+
+        UNKNOWN
+      end
+
+      # Managed mode (unix socket via puma) applies to live Rack apps.
+      def managed?(framework)
+        framework == RAILS || framework == RACK
+      end
+
+      def rails?(path)
+        path.join("config", "application.rb").file? &&
+          path.join("config", "application.rb").read.match?(/<\s*Rails::Application/)
+      rescue SystemCallError
+        false
+      end
+
+      def rack?(path)
+        path.join("config.ru").file?
+      end
+
+      def jekyll?(path)
+        path.join("_config.yml").file? && gemfile_includes?(path, "jekyll")
+      end
+
+      def bridgetown?(path)
+        path.join("bridgetown.config.yml").file? ||
+          (path.join("config", "initializers").directory? && gemfile_includes?(path, "bridgetown"))
+      end
+
+      def middleman?(path)
+        path.join("config.rb").file? && gemfile_includes?(path, "middleman")
+      end
+
+      def procfile?(path)
+        path.join("Procfile.dev").file? || path.join("Procfile").file?
+      end
+
+      def gemfile_includes?(path, gem_name)
+        gemfile = path.join("Gemfile")
+        return false unless gemfile.file?
+
+        gemfile.read.match?(/gem\s+["']#{Regexp.escape(gem_name)}["']/)
+      rescue SystemCallError
+        false
+      end
+    end
+  end
+end

data/lib/ask/local/hostname.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ask
+  module Local
+    # Hostname composition: {variant}.{service}.{app}.{tld}
+    #
+    # Each axis is independent. The web service is bare (myapp.localhost);
+    # any other service prefixes (api.myapp.localhost). A variant prefixes
+    # everything (fix-ui.myapp.localhost, fix-ui.api.myapp.localhost).
+    # An explicit full hostname bypasses composition entirely.
+    module Hostname
+      DEFAULT_TLD = "localhost"
+
+      module_function
+
+      # Build hostnames for every configured TLD.
+      def build(app:, tlds: [DEFAULT_TLD], service: nil, variant: nil)
+        tld_list = Array(tlds).flatten.compact
+        tld_list = [DEFAULT_TLD] if tld_list.empty?
+        tld_list.map { |tld| compose(app: app, tld: tld, service: service, variant: variant) }
+      end
+
+      def compose(app:, tld:, service: nil, variant: nil)
+        parts = [app.to_s]
+        # The web service is bare (myapp.localhost); every other service
+        # prefixes (api.myapp.localhost). "web" is the default service.
+        svc = service.to_s
+        parts.unshift(svc) if !svc.empty? && svc != "web"
+        parts.unshift(variant.to_s) if variant && !variant.to_s.empty?
+        "#{parts.join(".")}.#{tld}"
+      end
+
+      def url(hostname, port:, tls:)
+        scheme = tls ? "https" : "http"
+        default_port = tls ? 443 : 80
+        suffix = (port == default_port) ? "" : ":#{port}"
+        "#{scheme}://#{hostname}#{suffix}"
+      end
+
+      # Strip an explicit :port from a Host header for routing.
+      def strip_port(authority)
+        authority.to_s.split(":").first.to_s.downcase
+      end
+    end
+  end
+end

data/lib/ask/local/hosts.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "resolv"
+require "timeout"
+
+module Ask
+  module Local
+    # /etc/hosts sync for Safari + custom TLDs (.localhost resolves natively
+    # in Chrome/Firefox/Edge; Safari uses the system resolver).
+    # Same managed-block approach as portless hosts.ts.
+    module Hosts
+      BEGIN_MARKER = "# --- ask-local begin ---"
+      END_MARKER = "# --- ask-local end ---"
+      PATH = "/etc/hosts"
+
+      module_function
+
+      def managed_block(hostnames)
+        lines = [BEGIN_MARKER]
+        hostnames.uniq.sort.each { |h| lines << "127.0.0.1 #{h}" }
+        lines << END_MARKER
+        "#{lines.join("\n")}\n"
+      end
+
+      def read(path = PATH)
+        File.read(path)
+      rescue SystemCallError
+        ""
+      end
+
+      def managed_hostnames(content = read)
+        inside = false
+        names = []
+        content.each_line do |line|
+          inside = true if line.strip == BEGIN_MARKER
+          next unless inside
+          break if line.strip == END_MARKER
+
+          parts = line.split
+          names.concat(parts[1..]) if parts.first == "127.0.0.1"
+        end
+        names
+      end
+
+      def sync(hostnames, path = PATH)
+        content = read(path)
+        block = managed_block(hostnames)
+        if content.include?(BEGIN_MARKER)
+          updated = content.sub(/#{Regexp.escape(BEGIN_MARKER)}.*?#{Regexp.escape(END_MARKER)}\n?/m, block)
+        else
+          updated = "#{content.rstrip}\n#{block}"
+        end
+        File.write(path, updated)
+        true
+      rescue SystemCallError
+        false
+      end
+
+      def clean(path = PATH)
+        content = read(path)
+        updated = content.sub(/#{Regexp.escape(BEGIN_MARKER)}.*?#{Regexp.escape(END_MARKER)}\n?/m, "")
+        File.write(path, updated)
+        true
+      rescue SystemCallError
+        false
+      end
+
+      def resolves?(hostname)
+        Timeout.timeout(2) { Resolv.getaddress(hostname) }
+        true
+      rescue Resolv::ResolvError, SystemCallError, Timeout::Error
+        false
+      end
+
+      def unresolved(hostnames)
+        hostnames.reject { |h| resolves?(h) }
+      end
+    end
+  end
+end

data/lib/ask/local/inference.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "pathname"
+
+module Ask
+  module Local
+    # Zero-flag app name inference.
+    #
+    # Order: ask-local.json "name" -> Rails module in config/application.rb ->
+    # gemspec name -> package.json name (for hybrid apps) -> git root basename
+    # -> directory basename. First non-empty sanitized name wins.
+    module Inference
+      CONFIG_FILENAME = "ask-local.json"
+
+      module_function
+
+      # Returns [name, source].
+      def infer(cwd = Dir.pwd)
+        from_config(cwd) ||
+          from_rails_module(cwd) ||
+          from_gemspec(cwd) ||
+          from_package_json(cwd) ||
+          from_git_root(cwd) ||
+          from_directory(cwd)
+      end
+
+      def from_config(cwd)
+        path = File.join(cwd, CONFIG_FILENAME)
+        return nil unless File.file?(path)
+
+        parsed = JSON.parse(File.read(path))
+        name = parsed["name"] || parsed.dig("apps", ".", "name")
+        return nil if name.nil? || name.strip.empty?
+
+        [Sanitize.hostname_label(name), "ask-local.json"]
+      rescue JSON::ParserError, SystemCallError
+        nil
+      end
+
+      # Myapp::Application -> myapp (walks up for config/application.rb).
+      def from_rails_module(cwd)
+        dir = Pathname.new(cwd)
+        until dir.root?
+          candidate = dir.join("config", "application.rb")
+          if candidate.file?
+            mod = parse_rails_module(candidate.read)
+            return [Sanitize.hostname_label(mod), "config/application.rb"] if mod
+          end
+          dir = dir.parent
+        end
+        nil
+      end
+
+      def parse_rails_module(source)
+        match = source.match(/module\s+([A-Z][A-Za-z0-9_]*)/)
+        return nil unless match
+
+        # CamelCase with digit runs -> kebab: Rails8Min => rails-8-min,
+        # MyApp => my-app. Underscores become hyphens as well.
+        match[1].gsub(/([a-z0-9])([A-Z])/, '\1-\2')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1-\2')
+          .gsub(/([a-zA-Z])(\d)/, '\1-\2')
+          .gsub(/(\d)([a-zA-Z])/, '\1-\2')
+          .tr("_", "-").downcase
+      end
+
+      # First *.gemspec with a name in cwd (non-recursive, top level only).
+      def from_gemspec(cwd)
+        Dir.glob(File.join(cwd, "*.gemspec")).sort.each do |path|
+          name = parse_gemspec_name(File.read(path))
+          next if name.nil? || name.empty?
+
+          base = name.split("/").last
+          labeled = Sanitize.hostname_label(base)
+          return [labeled, File.basename(path)] unless labeled.empty?
+        end
+        nil
+      rescue SystemCallError
+        nil
+      end
+
+      def parse_gemspec_name(source)
+        match = source.match(/\.name\s*=\s*["']([^"']+)["']/)
+        match && match[1]
+      end
+
+      def from_package_json(cwd)
+        dir = Pathname.new(cwd)
+        until dir.root?
+          pkg = dir.join("package.json")
+          if pkg.file?
+            parsed = JSON.parse(pkg.read)
+            raw = parsed["name"]
+            if raw.is_a?(String) && !raw.empty?
+              base = raw.sub(%r{\A@[^/]+/}, "")
+              labeled = Sanitize.hostname_label(base)
+              return [labeled, "package.json"] unless labeled.empty?
+            end
+          end
+          dir = dir.parent
+        end
+        nil
+      rescue JSON::ParserError, SystemCallError
+        nil
+      end
+
+      def from_git_root(cwd)
+        root = git_root(cwd)
+        return nil unless root
+
+        labeled = Sanitize.hostname_label(File.basename(root))
+        labeled.empty? ? nil : [labeled, "git root"]
+      end
+
+      def from_directory(cwd)
+        labeled = Sanitize.hostname_label(File.basename(File.expand_path(cwd)))
+        raise Error, "Could not infer a project name from #{cwd}" if labeled.empty?
+
+        [labeled, "directory name"]
+      end
+
+      def git_root(cwd)
+        out, status = Open3.capture2("git", "rev-parse", "--show-toplevel",
+          chdir: cwd, err: File::NULL)
+        return out.strip if status.success? && !out.strip.empty?
+
+        walk_up_for_git(cwd)
+      rescue SystemCallError, ArgumentError
+        walk_up_for_git(cwd)
+      end
+
+      def walk_up_for_git(cwd)
+        dir = Pathname.new(File.expand_path(cwd))
+        until dir.root?
+          return dir.to_s if dir.join(".git").exist?
+          dir = dir.parent
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/ask/local/log.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ask
+  module Local
+    # Size-based log rotation. Nothing rotated today: proxy.log grows
+    # forever and every managed boot appends to the app log — a Rails app
+    # with HMR polling plus a long-lived daemon eventually fills the disk,
+    # and ENOSPC on the socket dir looks like our bug. Rotate before write.
+    module Log
+      # Rotate when the file exceeds this size; keep one generation.
+      MAX_BYTES = Integer(ENV.fetch("ASK_LOCAL_LOG_MAX_BYTES", 5 * 1024 * 1024))
+      KEEP_GENERATIONS = 1
+
+      module_function
+
+      # Open path for appending, rotating first if oversize. Returns the
+      # open File so spawn(out:) can take it directly.
+      def open_append(path, max_bytes: MAX_BYTES)
+        rotate(path, max_bytes: max_bytes)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, "a")
+      end
+
+      def rotate(path, max_bytes: MAX_BYTES)
+        return unless File.file?(path)
+        return unless File.size(path) > max_bytes
+
+        KEEP_GENERATIONS.downto(1) do |gen|
+          src = gen == 1 ? path : "#{path}.#{gen - 1}"
+          dst = "#{path}.#{gen}"
+          FileUtils.mv(src, dst, force: true) if File.file?(src)
+        end
+      rescue SystemCallError
+        nil
+      end
+
+      # Bytes under dir (state dir or app log dir), for doctor reporting.
+      def disk_usage(dir)
+        total = 0
+        Dir.glob(File.join(dir, "**", "*")).each do |f|
+          total += File.size(f) if File.file?(f)
+        rescue SystemCallError
+          nil
+        end
+        total
+      end
+
+      def human_bytes(bytes)
+        if bytes >= 1024 * 1024
+          format("%.1f MB", bytes.to_f / (1024 * 1024))
+        elsif bytes >= 1024
+          format("%.1f KB", bytes.to_f / 1024)
+        else
+          "#{bytes} B"
+        end
+      end
+    end
+  end
+end

data/lib/ask/local/ownership.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "etc"
+require "fileutils"
+
+module Ask
+  module Local
+    # File ownership across the root/user boundary.
+    #
+    # The sudo-spawned daemon and the root LaunchDaemon both write into
+    # the invoking user's state dir. The first root-owned file lands,
+    # the unprivileged CLI can no longer register routes — and the
+    # failure looks like corruption, not permissions. Every root write
+    # path calls fix() so the tree stays user-owned.
+    module Ownership
+      module_function
+
+      # The user behind sudo, or nil when not elevated.
+      def invoking_user
+        sudo_user = ENV["SUDO_USER"]
+        return nil if sudo_user.nil? || sudo_user.empty?
+
+        Etc.getpwnam(sudo_user)
+      rescue ArgumentError
+        nil
+      end
+
+      # Chown path (recursively for dirs) to the invoking user. No-op
+      # when not running as root or when the user cannot be resolved.
+      def fix(*paths)
+        user = invoking_user
+        return unless user
+        return unless Process.uid.zero?
+
+        paths.each do |path|
+          begin
+            if File.directory?(path) && !File.symlink?(path)
+              FileUtils.chown_R(user.uid, user.gid, path)
+            else
+              FileUtils.chown(user.uid, user.gid, path)
+            end
+          rescue SystemCallError, ArgumentError
+            nil
+          end
+        end
+      end
+
+      # Fresh state files a root proxy creates: routes, pid/port/tls
+      # markers and the log. Called after ensure_dir in daemon boot paths.
+      def chown_state_dir(dir)
+        fix(dir)
+      end
+
+      # The LaunchDaemon plist root writes into /Library/LaunchDaemons:
+      # root-owned is correct there, but record it so `service status`
+      # can explain the split.
+      def chown_service_files(*paths)
+        fix(*paths)
+      end
+    end
+  end
+end

data/lib/ask/local/ports.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Ask
+  module Local
+    # Ephemeral TCP ports for run-mode backends (4000-4999, portless range).
+    # Random-first then sequential; WHATWG blocked ports skipped.
+    module Ports
+      MIN_PORT = 4000
+      MAX_PORT = 4999
+      RANDOM_ATTEMPTS = 50
+
+      # Browsers refuse these (WHATWG fetch "bad port" list); Next.js too.
+      BLOCKED = [0, 1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42,
+        43, 53, 69, 77, 79, 87, 95, 101, 102, 103, 104, 109, 110, 111, 113,
+        115, 117, 119, 123, 135, 137, 139, 143, 161, 179, 389, 427, 465, 512,
+        513, 514, 515, 526, 530, 531, 532, 540, 548, 554, 556, 563, 587, 601,
+        636, 989, 990, 993, 995, 1719, 1720, 1723, 2049, 3659, 4045, 4190,
+        5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668, 6669, 6679, 6697,
+        10080].to_h { |p| [p, true] }.freeze
+
+      module_function
+
+      def free?(port)
+        server = TCPServer.new("127.0.0.1", port)
+        server.close
+        true
+      rescue SystemCallError
+        false
+      end
+
+      def find_free(min: MIN_PORT, max: MAX_PORT)
+        raise Error, "min (#{min}) must be <= max (#{max})" if min > max
+
+        RANDOM_ATTEMPTS.times do
+          port = min + rand(max - min + 1)
+          return port if !BLOCKED[port] && free?(port)
+        end
+        (min..max).each do |port|
+          return port if !BLOCKED[port] && free?(port)
+        end
+        raise Error, "No free port found in range #{min}-#{max}"
+      end
+    end
+  end
+end