workspaces 0.1.0

data/lib/workspaces/environment_overrides.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+
+module Workspaces
+  class EnvironmentOverrides
+    class Invalid < ArgumentError; end
+
+    NAME_PATTERN = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+    BLOCKED_PREFIXES = %w(WORKSPACE_ WORKSPACES_).freeze
+    BLOCKED_NAMES = %w(PORT WWW_HOST CANONICAL_HOST WEBPACK_ASSET_HOST).freeze
+    MAX_ENTRIES = 100
+    MAX_VALUE_BYTES = 8192
+    MAX_BODY_BYTES = 128 * 1024
+
+    def initialize(workspace_id, home: Config.home)
+      @workspace_id = Config.validate_id!(workspace_id.to_s)
+      @home = home
+    end
+
+    def load
+      reject_symlink!(directory_path)
+      reject_symlink!(file_path)
+      return {} unless file_path.exist?
+
+      parsed = JSON.parse(file_path.read)
+      raise Invalid, 'Stored environment overrides are invalid' unless parsed.is_a?(Hash)
+
+      validate_entries!(parsed)
+    rescue JSON::ParserError
+      raise Invalid, 'Stored environment overrides are invalid'
+    end
+
+    def keys
+      load.keys.sort
+    end
+
+    def apply_patch(set:, remove:)
+      validate_patch!(set, remove)
+      updated = load.merge(set)
+      remove.each { |name| updated.delete(name) }
+      validate_entries!(updated)
+      persist(updated)
+      updated
+    end
+
+    def clear!
+      delete_file!
+    end
+
+    def scrub(value)
+      text = value.to_s.encode('UTF-8', invalid: :replace, undef: :replace)
+      scrub_values.each do |secret|
+        text = text.gsub(secret, '[FILTERED]')
+      end
+      text
+    end
+
+    private
+
+    attr_reader :workspace_id, :home
+
+    def directory_path
+      home.join('environment')
+    end
+
+    def file_path
+      directory_path.join("#{workspace_id}.json")
+    end
+
+    def validate_patch!(set, remove)
+      set_names = validate_set!(set)
+      remove_names = validate_remove!(remove)
+      return unless set_names.intersect?(remove_names)
+
+      raise Invalid, 'Environment changes cannot set and remove the same name'
+    end
+
+    def validate_set!(set)
+      raise Invalid, 'Environment updates must be a mapping of names to string values' unless set.is_a?(Hash)
+
+      set.each do |name, value|
+        validate_name!(name)
+        validate_value!(value)
+      end
+      set.keys
+    end
+
+    def validate_remove!(remove)
+      raise Invalid, 'Environment removals must be an array of names' unless remove.is_a?(Array)
+
+      remove.each { |name| validate_name!(name) }
+      remove
+    end
+
+    def validate_entries!(entries)
+      raise Invalid, 'Stored environment overrides are invalid' unless entries.is_a?(Hash)
+      raise Invalid, 'Environment overrides are limited to 100 entries' if entries.length > MAX_ENTRIES
+
+      entries.each_with_object({}) do |(name, value), normalized|
+        validate_name!(name)
+        validate_value!(value)
+        normalized[name] = value
+      end
+    end
+
+    def validate_name!(name)
+      unless name.is_a?(String) && name.match?(NAME_PATTERN)
+        raise Invalid, 'Environment names must match /^[A-Za-z_][A-Za-z0-9_]*$/'
+      end
+      raise Invalid, 'Environment name is reserved for the workspace runner' if reserved_name?(name)
+    end
+
+    def validate_value!(value)
+      raise Invalid, 'Environment values must be strings' unless value.is_a?(String)
+      raise Invalid, 'Environment values must not contain NUL bytes' if value.include?("\0")
+      return if value.bytesize <= MAX_VALUE_BYTES
+
+      raise Invalid, 'Environment values must be 8192 bytes or smaller'
+    end
+
+    def reserved_name?(name)
+      BLOCKED_NAMES.include?(name) || BLOCKED_PREFIXES.any? { |prefix| name.start_with?(prefix) }
+    end
+
+    def persist(entries)
+      ensure_directory!
+      reject_symlink!(file_path)
+      return delete_file! if entries.empty?
+
+      temp_path = directory_path.join(".#{workspace_id}.#{Process.pid}.#{SecureRandom.hex(6)}.tmp")
+      begin
+        write_temp_file(temp_path, entries)
+        File.rename(temp_path, file_path)
+        File.chmod(0o600, file_path)
+      ensure
+        File.unlink(temp_path) if temp_path.exist?
+      end
+    end
+
+    def write_temp_file(path, entries)
+      File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
+        file.write(JSON.pretty_generate(entries))
+        file.flush
+        file.fsync
+      end
+    end
+
+    def delete_file!
+      return unless file_path.exist?
+
+      reject_symlink!(file_path)
+      File.unlink(file_path)
+    end
+
+    def ensure_directory!
+      if directory_path.exist?
+        reject_symlink!(directory_path)
+        raise Invalid, 'Environment storage path is invalid' unless directory_path.directory?
+      else
+        directory_path.mkpath
+      end
+      File.chmod(0o700, directory_path)
+    end
+
+    def reject_symlink!(path)
+      raise Invalid, 'Environment storage does not allow symlinks' if path.symlink?
+    end
+
+    def scrub_values
+      load.values.reject(&:empty?).uniq.sort_by { |value| -value.bytesize }
+    rescue Invalid
+      []
+    end
+  end
+end

data/lib/workspaces/front_door.rb

@@ -0,0 +1,275 @@
+require 'rack'
+require 'json'
+require 'uri'
+require 'net/http'
+require_relative 'coordinator'
+require_relative 'dashboard_view'
+require_relative 'environment_overrides'
+
+module Workspaces
+  class FrontDoor
+    WORKSPACE_ROUTE = %r{\A/workspaces/([a-z0-9]+(?:-[a-z0-9]+)*)
+                          (?:/(status|start|prepare|restart|stop|environment))?\z}x
+
+    def initialize(coordinator: Coordinator.new, registry: Registry.new)
+      @coordinator = coordinator
+      @registry = registry
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      authority = request_authority(request)
+      return response(400, 'Unexpected Host header.') unless authority
+
+      id = Config.preview_workspace_id(authority.host)
+      return proxy(id, request) if id && valid_authority?(authority, URI(Config.preview_url(id)))
+      return response(400, 'Unexpected Host header.') unless valid_authority?(authority, Config.public_uri)
+
+      route(request)
+    rescue Worktree::AuthenticationError
+      response(422, DashboardView.checkout_authentication_error(request.path_info), type: 'text/html')
+    rescue ArgumentError, Worktree::CommandFailedError => e
+      response(422, e.message)
+    end
+
+    private
+
+    def route(request)
+      return index(request) if ['/', '/workspaces'].include?(request.path_info)
+      return create(request) if request.path_info == '/workspaces/create'
+      pr_match = %r{\A/pr/([1-9][0-9]*)\z}.match(request.path_info)
+      return pr_preview(request, pr_match[1]) if pr_match
+
+      workspace_route(request)
+    end
+
+    def workspace_route(request)
+      match = WORKSPACE_ROUTE.match(request.path_info)
+      return response(404, 'Not found. Visit /workspaces.') unless match
+
+      id, action = match.captures
+      return response(404, 'Unknown managed workspace') unless Worktree.new(id).exists?
+
+      action_request(request, id, action)
+    end
+
+    def pr_preview(request, number)
+      if safe?(request)
+        page = DashboardView.pull_request(number, @registry.list(pr: number))
+        return response(200, page, type: 'text/html', head: request.head?)
+      end
+      return response(405, 'Use GET, HEAD or POST') unless request.post?
+      return response(403, 'Creation requires the configured dashboard origin') unless same_origin?(request)
+
+      workspace = @registry.create(pr: number)
+      @coordinator.start(workspace.id)
+      redirect(Config.dashboard_url(workspace.id))
+    end
+
+    def index(request)
+      return response(405, 'Use GET or HEAD') unless safe?(request)
+
+      response(200, DashboardView.index(@registry.list), type: 'text/html', head: request.head?)
+    end
+
+    def action_request(request, id, action)
+      return update_environment(request, id) if action == 'environment'
+      return status_response(request, id, action) if action.nil? || action == 'status'
+      return response(405, 'Use POST') unless request.post?
+      return response(403, 'Actions require the configured dashboard origin') unless same_origin?(request)
+
+      perform_action(id, action)
+      redirect(Config.dashboard_url(id))
+    end
+
+    def status_response(request, id, action)
+      return response(405, 'Use GET or HEAD') unless safe?(request)
+
+      source = request.params.fetch('log', 'setup')
+      return response(400, 'Unknown workspace log') unless %w(setup backend).include?(source)
+
+      snapshot = @coordinator.snapshot(id, log: source)
+      body = action ? JSON.generate(snapshot) : DashboardView.render(snapshot)
+      response(200, body, type: action ? 'application/json' : 'text/html', head: request.head?)
+    end
+
+    def perform_action(id, action)
+      case action
+      when 'start' then @coordinator.start(id)
+      when 'prepare' then @coordinator.start(id, force: true)
+      when 'restart' then @coordinator.restart(id)
+      when 'stop' then stop(id)
+      end
+    end
+
+    def update_environment(request, id)
+      return response(405, 'Use POST') unless request.post?
+      return response(403, 'Actions require the configured dashboard origin') unless same_origin?(request)
+
+      updated = @coordinator.update_environment(id, **parse_environment_changes(request))
+      return response(409, 'Workspace is busy preparing, restarting, or running a command') unless updated
+
+      redirect(Config.dashboard_url(id))
+    rescue EnvironmentOverrides::Invalid => e
+      response(422, e.message)
+    end
+
+    def stop(id)
+      @registry.with_lock(id) do
+        Backend.new(id).stop!
+        StateStore.new(Config.state_file).set(id, 'status' => 'stopped', 'message' => 'Server stopped')
+      end
+    end
+
+    def create(request)
+      return response(405, 'Use POST') unless request.post?
+      return response(403, 'Creation requires the configured dashboard origin') unless same_origin?(request)
+
+      params = request.POST
+      options = {}
+      %w(branch pr new_branch from).each { |key| options[key.to_sym] = params[key] unless params[key].to_s.empty? }
+      workspace = @registry.create(**options)
+      redirect(Config.dashboard_url(workspace.id))
+    end
+
+    def parse_environment_changes(request)
+      validate_environment_content_type!(request)
+      raw = environment_body(request)
+      params = Rack::Utils.parse_nested_query(raw)
+      { set: normalize_set(params['set']), remove: normalize_remove(params['remove']) }
+    end
+
+    def validate_environment_content_type!(request)
+      return if ['', 'application/x-www-form-urlencoded'].include?(request.media_type.to_s)
+
+      raise EnvironmentOverrides::Invalid, 'Environment updates must use form-encoded parameters'
+    end
+
+    def environment_body(request)
+      limit = EnvironmentOverrides::MAX_BODY_BYTES
+      if request.content_length.to_i > limit
+        raise EnvironmentOverrides::Invalid,
+              'Environment update payload is too large'
+      end
+
+      raw = request.body.read(limit + 1).to_s
+      raise EnvironmentOverrides::Invalid, 'Environment update payload is too large' if raw.bytesize > limit
+
+      raw
+    end
+
+    def normalize_set(values)
+      return {} if values.nil?
+      unless values.is_a?(Hash)
+        raise EnvironmentOverrides::Invalid,
+              'Environment updates must use set[NAME]=VALUE form fields'
+      end
+
+      values.transform_keys(&:to_s).transform_values(&:to_s)
+    end
+
+    def normalize_remove(values)
+      case values
+      when nil then []
+      when String then [values]
+      when Array then values.map(&:to_s)
+      else raise EnvironmentOverrides::Invalid, 'Environment removals must use remove[]=NAME form fields'
+      end
+    end
+
+    def proxy(id, request)
+      return response(404, 'Unknown managed workspace') unless Worktree.new(id).exists?
+
+      snapshot = @coordinator.snapshot(id, include_log: false)
+      return unavailable(id, request) unless snapshot['status'] == 'ready' && !snapshot['active']
+
+      forward(id, request)
+    rescue IOError, SystemCallError, Timeout::Error => e
+      response(502, "Workspace backend unavailable: #{e.class}")
+    end
+
+    def unavailable(id, request)
+      return redirect(Config.dashboard_url(id)) if safe?(request)
+
+      response(503, "Workspace not ready. Visit #{Config.dashboard_url(id)}")
+    end
+
+    def forward(id, request)
+      uri = URI("http://127.0.0.1:#{Backend.new(id).port}#{request.fullpath}")
+      upstream = upstream_request(id, request, uri)
+      result = Net::HTTP.start(uri.host, uri.port, open_timeout: 5, read_timeout: 60) { |http| http.request(upstream) }
+      [result.code.to_i, response_headers(result),
+       request.head? ? [] : [result.body || '']]
+    end
+
+    def upstream_request(id, request, uri)
+      upstream = Net::HTTPGenericRequest.new(request.request_method, !safe?(request), !request.head?, uri.request_uri)
+      copy_request_headers(request, upstream)
+      forwarding_headers(id).each { |key, value| upstream[key] = value }
+      upstream.body = request.body.read unless safe?(request)
+      upstream
+    end
+
+    def copy_request_headers(request, upstream)
+      request.each_header do |key, value|
+        next unless key.start_with?('HTTP_') || %w(CONTENT_TYPE CONTENT_LENGTH).include?(key)
+        next if key == 'HTTP_FORWARDED' || key.start_with?('HTTP_X_FORWARDED_')
+
+        upstream[key.delete_prefix('HTTP_').tr('_', '-')] = value
+      end
+    end
+
+    def forwarding_headers(id)
+      { 'Host' => Config.preview_host(id), 'X-Forwarded-Host' => Config.preview_host(id),
+        'X-Forwarded-Port' => Config.public_uri.port.to_s, 'X-Forwarded-Proto' => Config.public_uri.scheme }
+    end
+
+    def response_headers(result)
+      headers = result.each_header.to_h.reject { |key, _| %w(transfer-encoding connection).include?(key) }
+      cookies = result.get_fields('set-cookie')
+      headers['set-cookie'] = cookies if cookies
+      headers
+    end
+
+    def safe?(request)
+      %w(GET HEAD).include?(request.request_method)
+    end
+
+    def same_origin?(request)
+      origin = request.get_header('HTTP_ORIGIN')
+      return origin == Config.public_origin if origin
+
+      uri = URI.parse(request.referer.to_s)
+      uri.is_a?(URI::HTTP) && uri.userinfo.nil? && "#{uri.scheme}://#{uri.authority}" == Config.public_origin
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def request_authority(request)
+      host = request.get_header('HTTP_HOST').to_s
+      return nil unless host.match?(/\A[a-zA-Z0-9.-]+(?::[0-9]+)?\z/)
+
+      URI.parse("#{Config.public_uri.scheme}://#{host}")
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def valid_authority?(actual, expected)
+      actual.host.casecmp?(expected.host) && actual.port == expected.port
+    end
+
+    def redirect(url)
+      [303, headers('text/plain').merge('location' => url), ["See #{url}\n"]]
+    end
+
+    def response(status, body, type: 'text/plain', head: false)
+      [status, headers(type), head ? [] : [body]]
+    end
+
+    def headers(type)
+      { 'content-type' => "#{type}; charset=utf-8", 'cache-control' => 'no-store',
+        'x-content-type-options' => 'nosniff', 'x-frame-options' => 'DENY',
+        'content-security-policy' => "frame-ancestors 'none'" }
+    end
+  end
+end

data/lib/workspaces/paths.rb

@@ -0,0 +1,63 @@
+require 'pathname'
+require 'digest'
+
+module Workspaces
+  module Paths
+    def home
+      @home ||= if ENV['WORKSPACES_HOME']
+                  Pathname.new(File.expand_path(ENV.fetch('WORKSPACES_HOME')))
+                else
+                  Pathname.new(self::DEFAULT_HOME).join(Digest::SHA256.hexdigest(repo_root.realpath.to_s)[0, 16])
+                end
+    end
+
+    def worktrees_dir(create: true)
+      directory('workspaces', create: create)
+    end
+
+    def logs_dir(create: true)
+      directory('logs', create: create)
+    end
+
+    def locks_dir(create: true)
+      directory('locks', create: create)
+    end
+
+    def state_file
+      home.join('state.json')
+    end
+
+    def log_path(workspace_id, create: true)
+      setup_log_path(workspace_id, create: create)
+    end
+
+    def setup_log_path(workspace_id, create: true)
+      logs_dir(create: create).join("#{workspace_id}.setup.log")
+    end
+
+    def backend_log_path(workspace_id, create: true)
+      logs_dir(create: create).join("#{workspace_id}.backend.log")
+    end
+
+    def prepare_lock_path(workspace_id)
+      locks_dir(create: false).join("#{workspace_id}.prepare.lock")
+    end
+
+    def boot_lock_path(workspace_id)
+      locks_dir(create: false).join("#{workspace_id}.lock")
+    end
+
+    def repo_root
+      return Pathname.new(File.expand_path(ENV.fetch('WORKSPACES_REPO_ROOT'))) if ENV['WORKSPACES_REPO_ROOT']
+
+      Pathname.pwd.ascend.find { |directory| directory.join('.workspaces.yml').file? && directory.join('.git').exist? } ||
+        raise(ArgumentError, 'Run inside a Git repository or set WORKSPACES_REPO_ROOT')
+    end
+
+    private
+
+    def directory(name, create:)
+      home.join(name).tap { |path| path.mkpath if create }
+    end
+  end
+end

data/lib/workspaces/port_allocator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Workspaces
+  # Finds a free local TCP port for a new PR backend, avoiding ports this tool already
+  # considers taken (per the state file) as well as ports something else on the box is using.
+  module PortAllocator
+    class NoFreePortError < StandardError; end
+
+    def self.allocate(range, taken_ports)
+      range.each do |port|
+        next if taken_ports.include?(port)
+        return port if free?(port)
+      end
+      raise NoFreePortError, "No free ports available in #{range}"
+    end
+
+    def self.free?(port)
+      return false if listening?(port)
+
+      server = TCPServer.new('127.0.0.1', port)
+      server.close
+      true
+    rescue Errno::EADDRINUSE
+      false
+    end
+
+    def self.listening?(port)
+      Socket.tcp('127.0.0.1', port, connect_timeout: 0.2) { true }
+    rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT
+      false
+    end
+  end
+end

data/lib/workspaces/presentation.rb

@@ -0,0 +1,68 @@
+module Workspaces
+  class Presentation
+    TITLES = { 'idle' => 'Ready to start', 'stopped' => 'Server stopped', 'ready' => 'Workspace ready',
+               'preparing' => 'Running setup', 'error' => 'Setup failed',
+               'interrupted' => 'Setup interrupted' }.freeze
+    ACTIONS = { 'start' => 'Start workspace', 'prepare' => 'Rebuild & restart',
+                'restart' => 'Restart server', 'stop' => 'Stop server' }.freeze
+
+    def initialize(snapshot)
+      @snapshot = snapshot
+    end
+
+    def to_h
+      { 'title' => title, 'busy' => busy?, 'error' => error, 'steps' => steps,
+        'actions' => actions, 'ready' => status == 'ready' && !busy? }
+    end
+
+    private
+
+    def status
+      @snapshot.fetch('status', 'idle')
+    end
+
+    def busy?
+      @snapshot['active'] || status == 'preparing'
+    end
+
+    def title
+      return 'Workspace busy' if @snapshot['active'] && !busy_status?
+      return @snapshot['message'] || 'Running setup' if status == 'preparing'
+
+      TITLES.fetch(status, 'Workspace status')
+    end
+
+    def busy_status?
+      status == 'preparing'
+    end
+
+    def error
+      return @snapshot['last_error'] unless status == 'interrupted'
+
+      'The setup process stopped before it finished. Retry to continue.'
+    end
+
+    def steps
+      @snapshot.fetch('steps', []).map do |step|
+        step.merge('state' => status == 'interrupted' && step['state'] == 'active' ? 'failed' : step['state'])
+      end
+    end
+
+    def actions
+      return [] if busy?
+      return %w(prepare restart stop).map { |key| action(key, false) } if status == 'ready'
+      return [retry_action] if %w(error interrupted).include?(status)
+
+      [action('start', true)]
+    end
+
+    def retry_action
+      restart = @snapshot['operation'] == 'restart'
+      action(restart ? 'restart' : 'prepare', true).merge('label' => restart ? 'Retry restart' : 'Retry setup')
+    end
+
+    def action(key, primary)
+      { 'key' => key, 'label' => ACTIONS.fetch(key), 'primary' => primary }
+    end
+  end
+end