lcp 0.1.0

data/lib/lcp_ruby/actions/action_executor.rb

@@ -0,0 +1,66 @@
+module LcpRuby
+  module Actions
+    class ActionExecutor
+      attr_reader :action_key, :context
+
+      def initialize(action_key, context = {})
+        @action_key = action_key.to_s
+        @context = context
+      end
+
+      def execute
+        action_class = ActionRegistry.action_for(action_key)
+        raise Error, "Action '#{action_key}' not found" unless action_class
+
+        record = context[:record]
+        user = context[:current_user]
+
+        return Actions::Result.unauthorized unless action_class.authorized?(record, user)
+
+        if context[:async] && defined?(LcpRuby::BackgroundJobs) && LcpRuby::BackgroundJobs.respond_to?(:enqueue)
+          return enqueue_async(record, user)
+        end
+
+        action = action_class.new(context)
+        action.call
+      rescue StandardError => e
+        Actions::Result.new(
+          success: false,
+          message: I18n.t("lcp_ruby.actions.execution_failed",
+                          reason: e.message,
+                          default: "Action failed: %{reason}"),
+          redirect_to: nil,
+          data: nil,
+          errors: [ e.message ]
+        )
+      end
+
+      private
+
+      def enqueue_async(record, user)
+        enqueue_params = {
+          job_type: "action:#{action_key}",
+          params: context.except(:record, :current_user, :async),
+          triggered_by: user
+        }
+
+        if record
+          model_name = LcpRuby.registry.name_for(record.class) rescue nil
+          enqueue_params[:target_model] = model_name if model_name
+          enqueue_params[:target_id] = record.id
+        end
+
+        LcpRuby::BackgroundJobs.enqueue(**enqueue_params)
+
+        Actions::Result.new(
+          success: true,
+          message: I18n.t("lcp_ruby.actions.enqueued",
+                          default: "Action enqueued for background execution"),
+          redirect_to: nil,
+          data: nil,
+          errors: []
+        )
+      end
+    end
+  end
+end

data/lib/lcp_ruby/actions/action_registry.rb

@@ -0,0 +1,48 @@
+module LcpRuby
+  module Actions
+    class ActionRegistry
+      class << self
+        def action_for(key)
+          registry[key.to_s]
+        end
+
+        def register(key, action_class)
+          registry[key.to_s] = action_class
+        end
+
+        def registered?(key)
+          registry.key?(key.to_s)
+        end
+
+        def discover!(base_path)
+          actions_path = File.join(base_path, "actions")
+          return unless File.directory?(actions_path)
+
+          Dir[File.join(actions_path, "**", "*.rb")].sort.each do |file|
+            require file
+
+            relative = file.sub("#{actions_path}/", "").sub(/\.rb$/, "")
+            class_name = "LcpRuby::HostActions::#{relative.split('/').map(&:camelize).join('::')}"
+
+            begin
+              action_class = class_name.constantize
+              register(relative, action_class)
+            rescue NameError => e
+              Rails.logger.warn("[LcpRuby] Could not register action #{class_name}: #{e.message}")
+            end
+          end
+        end
+
+        def clear!
+          @registry = {}
+        end
+
+        private
+
+        def registry
+          @registry ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/actions/api_tokens/revoke.rb

@@ -0,0 +1,13 @@
+module LcpRuby
+  module Actions
+    module ApiTokens
+      class Revoke < LcpRuby::Actions::BaseAction
+        def call
+          @record.update!(revoked_at: Time.current)
+          success(message: I18n.t("lcp_ruby.api_tokens.revoked",
+            default: "Token revoked."))
+        end
+      end
+    end
+  end
+end

data/lib/lcp_ruby/actions/base_action.rb

@@ -0,0 +1,79 @@
+module LcpRuby
+  module Actions
+    class BaseAction
+      attr_reader :record, :records, :current_user, :params, :model_class
+
+      def initialize(context = {})
+        @record = context[:record]
+        @records = context[:records]
+        @current_user = context[:current_user]
+        @params = context[:params] || {}
+        @model_class = context[:model_class]
+      end
+
+      def call
+        raise NotImplementedError, "#{self.class}#call must be implemented"
+      end
+
+      # Override to define a form shown before execution (modal)
+      def self.param_schema
+        nil
+      end
+
+      # Override for visibility conditions beyond what YAML visible_when provides
+      def self.visible?(_record, _user)
+        true
+      end
+
+      # Override for extra authorization beyond permission YAML
+      def self.authorized?(_record, _user)
+        true
+      end
+
+      # Override in subclass to indicate the action handles batch iteration internally.
+      # When true, the action receives the full records array in a single call.
+      # When false (default), the platform iterates per-record automatically.
+      def self.batch_capable?
+        false
+      end
+
+      protected
+
+      def success(message: nil, redirect_to: nil, data: nil)
+        Result.new(success: true, message: message, redirect_to: redirect_to, data: data, errors: [])
+      end
+
+      def failure(message:, errors: [])
+        Result.new(success: false, message: message, redirect_to: nil, data: nil, errors: errors)
+      end
+
+      def continue(data:)
+        Result.new(type: :continue, success: true, data: data, errors: [])
+      end
+
+      def file_download(file_data:, filename:, content_type:)
+        Result.new(type: :file_download, success: true,
+                   data: { file_data: file_data, filename: filename, content_type: content_type }, errors: [])
+      end
+    end
+
+    Result = Data.define(:type, :success, :message, :redirect_to, :data, :errors) do
+      def initialize(type: :success, success:, message: nil, redirect_to: nil, data: nil, errors: [])
+        super(type:, success:, message:, redirect_to:, data:, errors:)
+      end
+
+      def self.unauthorized
+        new(
+          success: false,
+          message: I18n.t("lcp_ruby.actions.not_authorized", default: "Not authorized to execute this action"),
+          errors: [ "unauthorized" ]
+        )
+      end
+
+      def success? = success
+      def failure? = !success
+      def continue? = type == :continue
+      def file_download? = type == :file_download
+    end
+  end
+end

data/lib/lcp_ruby/actions/form_action_pipeline.rb

@@ -0,0 +1,138 @@
+module LcpRuby
+  module Actions
+    class FormActionPipeline
+      PipelineResult = Data.define(:success, :message, :redirect_to, :deferred_events, :errors) do
+        def initialize(success:, message: nil, redirect_to: nil, deferred_events: [], errors: [])
+          super
+        end
+
+        def success? = success
+        def failure? = !success
+      end
+
+      # @param record [ActiveRecord::Base] record with user params + set_fields already applied
+      # @param pipeline [Array] normalized pipeline steps, e.g. ["save", {"transition"=>"submit"}]
+      # @param user [Object] current_user
+      # @param evaluator [PermissionEvaluator]
+      # @param model_name [String] LCP model name (for action key resolution)
+      # @param model_class [Class] ActiveRecord model class
+      # @param params [Hash] action params (for custom actions)
+      # @return [PipelineResult]
+      def self.execute(record, pipeline, user:, evaluator:, model_name:, model_class:, params: {})
+        new(record, pipeline,
+          user: user, evaluator: evaluator,
+          model_name: model_name, model_class: model_class,
+          params: params).execute
+      end
+
+      def initialize(record, pipeline, user:, evaluator:, model_name:, model_class:, params: {})
+        @record = record
+        @pipeline = pipeline
+        @user = user
+        @evaluator = evaluator
+        @model_name = model_name
+        @model_class = model_class
+        @params = params
+        @deferred_events = []
+        @last_message = nil
+        @last_redirect_to = nil
+      end
+
+      def execute
+        success = false
+
+        ActiveRecord::Base.transaction do
+          @pipeline.each { |step| execute_step(step) }
+          success = true
+        rescue StepFailure
+          raise ActiveRecord::Rollback
+        end
+
+        if success
+          PipelineResult.new(
+            success: true,
+            message: @last_message,
+            redirect_to: @last_redirect_to,
+            deferred_events: @deferred_events
+          )
+        else
+          PipelineResult.new(
+            success: false,
+            errors: @record.errors.full_messages
+          )
+        end
+      end
+
+      private
+
+      # Internal signal for step failure — never escapes execute.
+      class StepFailure < StandardError; end
+
+      def execute_step(step)
+        case step
+        when "save"
+          execute_save
+        when Hash
+          if step.key?("transition")
+            execute_transition(step["transition"])
+          elsif step.key?("action")
+            execute_action(step["action"])
+          else
+            @record.errors.add(:base, "Unknown pipeline step: #{step.inspect}")
+            raise StepFailure
+          end
+        else
+          @record.errors.add(:base, "Unknown pipeline step: #{step.inspect}")
+          raise StepFailure
+        end
+      end
+
+      def execute_save
+        saved = @record.save
+        Workflow::TransitionExecutor.reset_transition_flag(@record)
+
+        raise StepFailure unless saved
+      end
+
+      def execute_transition(transition_name)
+        result = Workflow::TransitionExecutor.execute(
+          @record, transition_name,
+          user: @user,
+          evaluator: @evaluator,
+          defer_events: true,
+          triggered_by: "pipeline"
+        )
+
+        @deferred_events.concat(result.deferred_events)
+      rescue Workflow::WorkflowError => e
+        @record.errors.add(:base, e.message)
+        raise StepFailure
+      end
+
+      def execute_action(action_name)
+        action_key = "#{@model_name}/#{action_name}"
+        context = {
+          record: @record,
+          current_user: @user,
+          params: @params,
+          model_class: @model_class
+        }
+
+        result = ActionExecutor.new(action_key, context).execute
+
+        if result.failure?
+          Array(result.errors).each { |err| @record.errors.add(:base, err) }
+          raise StepFailure
+        end
+
+        @last_message = result.message if result.message.present?
+        @last_redirect_to = result.redirect_to if result.redirect_to.present?
+      rescue StepFailure
+        raise
+      rescue StandardError => e
+        @record.errors.add(:base, e.message)
+        raise StepFailure
+      end
+    end
+  end
+end

data/lib/lcp_ruby/aggregates/query_builder.rb

@@ -0,0 +1,6 @@
+module LcpRuby
+  module Aggregates
+    # Backward compatibility alias — QueryBuilder is now VirtualColumns::Builder
+    QueryBuilder = VirtualColumns::Builder
+  end
+end

data/lib/lcp_ruby/api_tokens/model_extension.rb

@@ -0,0 +1,41 @@
+module LcpRuby
+  module ApiTokens
+    module ModelExtension
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :plaintext_token
+
+        before_validation :default_user_id_to_current_user, on: :create
+        before_validation :generate_token!, on: :create
+        validate :expires_at_must_be_future
+      end
+
+      private
+
+      def default_user_id_to_current_user
+        return if user_id.present?
+        self.user_id = LcpRuby::Current.user&.id
+      end
+
+      def generate_token!
+        return if token_hash.present?
+
+        self.plaintext_token = LcpRuby::ApiTokens::TokenGenerator.generate
+        self.token_prefix    = LcpRuby::ApiTokens::TokenGenerator.prefix(plaintext_token)
+        self.token_hash      = LcpRuby::ApiTokens::TokenGenerator.hash(plaintext_token)
+      end
+
+      def expires_at_must_be_future
+        return if expires_at.nil?
+        return if expires_at >= Date.current
+
+        errors.add(
+          :expires_at,
+          I18n.t("lcp_ruby.api_tokens.errors.expires_at_must_be_future",
+            default: "must be in the future")
+        )
+      end
+    end
+  end
+end

data/lib/lcp_ruby/api_tokens/resolver_registry.rb

@@ -0,0 +1,53 @@
+module LcpRuby
+  module ApiTokens
+    module ResolverRegistry
+      Resolver = Struct.new(:name, :priority, :matcher, :resolver, keyword_init: true)
+
+      @resolvers = {}
+      @sorted = nil
+
+      def self.register(name, priority:, matcher:, resolver:)
+        @resolvers[name.to_sym] = Resolver.new(
+          name: name.to_sym,
+          priority: priority,
+          matcher: matcher,
+          resolver: resolver
+        )
+        @sorted = nil
+      end
+
+      def self.resolve(token_string)
+        return nil if token_string.nil? || token_string.empty?
+
+        sorted_resolvers.each do |r|
+          next unless r.matcher.call(token_string)
+          return r.resolver.call(token_string)
+        end
+        nil
+      end
+
+      def self.matched?(token_string)
+        return false if token_string.nil? || token_string.empty?
+        sorted_resolvers.any? { |r| r.matcher.call(token_string) }
+      end
+
+      def self.registered?(name)
+        @resolvers.key?(name.to_sym)
+      end
+
+      def self.size
+        @resolvers.size
+      end
+
+      def self.clear!
+        @resolvers = {}
+        @sorted = nil
+      end
+
+      def self.sorted_resolvers
+        @sorted ||= @resolvers.values.sort_by { |r| -r.priority }
+      end
+      private_class_method :sorted_resolvers
+    end
+  end
+end

data/lib/lcp_ruby/api_tokens/token_generator.rb

@@ -0,0 +1,27 @@
+require "securerandom"
+require "digest"
+
+module LcpRuby
+  module ApiTokens
+    module TokenGenerator
+      PREFIX = "lcp_pat_".freeze
+      PREFIX_DISPLAY_LENGTH = 12
+
+      def self.generate
+        "#{PREFIX}#{SecureRandom.urlsafe_base64(32)}"
+      end
+
+      def self.hash(plaintext)
+        Digest::SHA256.hexdigest(plaintext.to_s)
+      end
+
+      def self.prefix(plaintext)
+        plaintext.to_s[0, PREFIX_DISPLAY_LENGTH]
+      end
+
+      def self.valid_format?(token)
+        token.to_s.start_with?(PREFIX)
+      end
+    end
+  end
+end

data/lib/lcp_ruby/api_tokens/verifier.rb

@@ -0,0 +1,38 @@
+require "active_support/security_utils"
+
+module LcpRuby
+  module ApiTokens
+    module Verifier
+      DEBOUNCE_INTERVAL = 1.minute
+
+      def self.verify(plaintext)
+        return nil if plaintext.nil? || plaintext.empty?
+
+        token_class = LcpRuby.registry.model_for("api_token")
+        return nil unless token_class
+
+        hash = TokenGenerator.hash(plaintext)
+        token = token_class.find_by(token_hash: hash)
+        return nil unless token
+
+        return nil unless ActiveSupport::SecurityUtils.secure_compare(token.token_hash.to_s, hash)
+        return nil if token.revoked_at.present?
+        return nil if token.expires_at.present? && token.expires_at < Date.current
+
+        touch_last_used_at(token)
+
+        user = token.user
+        return nil if user.nil?
+        return nil if user.respond_to?(:active?) && !user.active?
+
+        user
+      end
+
+      def self.touch_last_used_at(token)
+        return if token.last_used_at.present? && token.last_used_at > DEBOUNCE_INTERVAL.ago
+
+        token.update_columns(last_used_at: Time.current)
+      end
+    end
+  end
+end

data/lib/lcp_ruby/app_template.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+# Rails application template for LCP Ruby
+# Invoked via: rails new my_app -m path/to/app_template.rb
+# ENV vars set by `lcp new` CLI:
+#   LCP_FORMAT             - "dsl" or "yaml" (default: "dsl")
+#   LCP_FEATURES           - comma-separated topologically-sorted feature names
+#   LCP_REQUESTED_FEATURES - comma-separated user-requested set (manifest only)
+#   LCP_PRESET             - preset name (manifest only)
+#   LCP_GEM_SOURCE         - "rubygems" or "path:/abs/path" (default: "rubygems")
+#   LCP_TIMEZONE           - default timezone (default: "UTC")
+#   LCP_LOCALE             - default locale (default: "en")
+#   LCP_MENU_LAYOUT        - "top", "sidebar", or "both" (default: "both")
+
+require "json"
+
+format             = ENV.fetch("LCP_FORMAT", "dsl")
+features           = ENV.fetch("LCP_FEATURES", "").split(",").map(&:strip).reject(&:empty?)
+requested_features = ENV.fetch("LCP_REQUESTED_FEATURES", "").split(",").map(&:strip).reject(&:empty?)
+preset             = ENV.fetch("LCP_PRESET", "custom")
+gem_source         = ENV.fetch("LCP_GEM_SOURCE", "rubygems")
+timezone           = ENV.fetch("LCP_TIMEZONE", "UTC")
+locale             = ENV.fetch("LCP_LOCALE", "en")
+menu_layout        = ENV.fetch("LCP_MENU_LAYOUT", "both")
+
+# Add lcp gem
+case gem_source
+when "rubygems"
+  gem "lcp"
+when /\Apath:(.*)\z/
+  gem "lcp", path: Regexp.last_match(1)
+when /\Agit:(.*)\z/
+  gem "lcp", git: Regexp.last_match(1)
+else
+  gem "lcp"
+end
+
+# Generators that accept --format option. Source of truth lives in
+# `LcpRuby::Generators::FeatureRegistry` once the gem is loaded
+# (`after_bundle`); this list mirrors the wizard's curated set.
+FORMAT_AWARE = %w[
+  install_auth custom_fields export import batch_operations
+  role_model permission_source groups
+  auditing monitoring saved_filters
+  pages background_jobs
+  workflow_definition workflow_approvals workflow_audit_log
+  gapfree_sequences
+].freeze
+
+after_bundle do
+  # Parser literal MUST stay byte-identical to install_generator.rb
+  # (drift test: spec/lib/lcp_ruby/generators/locale_parser_drift_spec.rb).
+  # .inspect-based interpolation below prevents hostile env breakout.
+  parsed_locales = locale.split(",").map(&:strip).reject(&:empty?).uniq.map(&:to_sym)
+  parsed_locales = [ :en ] if parsed_locales.empty?  # LCP_LOCALE="" → safe default
+  default_locale = parsed_locales.first
+
+  application_block = +<<~RUBY.indent(4)
+
+    config.time_zone = #{timezone.inspect}
+    config.i18n.default_locale = #{default_locale.inspect}
+  RUBY
+
+  unless parsed_locales == [ :en ]
+    application_block << <<~RUBY.indent(4)
+
+      # LCP filters Accept-Language through I18n.available_locales — listing
+      # :en here would let a browser's en-US flip the UI to English before
+      # default_locale is consulted. Fallbacks below operate at the backend
+      # layer (independent of available_locales). See docs/guides/adding-locale.md.
+      config.i18n.available_locales = #{parsed_locales.inspect}
+    RUBY
+
+    if !parsed_locales.include?(:en) && default_locale != :en
+      # Build hash literal manually — Hash#inspect would emit rocket form `{:cs=>:en}`.
+      fallback_pairs = parsed_locales.map { |l| "#{l}: :en" }.join(", ")
+      application_block << <<~RUBY.indent(4)
+        config.i18n.fallbacks = { #{fallback_pairs} }
+      RUBY
+    end
+  end
+
+  inject_into_file "config/application.rb",
+    application_block,
+    after: /class Application < Rails::Application\n/
+
+  # Core install — runs before features. Manifest tracks features only;
+  # core install failures fail the whole template via Rails' default
+  # abort_on_failure behaviour (no `inline:`).
+  # Core install also sets up agent affordances at the end (skills +
+  # CLAUDE.md/AGENTS.md via `lcp_ruby:agent_setup`) — passive, no runtime impact.
+  generate "lcp_ruby:install",
+    "--format=#{format}",
+    "--menu-layout=#{menu_layout}",
+    "--locale=#{locale}"
+
+  # Build manifest header before the feature loop so even an empty preset
+  # produces a manifest the doctor can introspect.
+  lcp_ruby_version = (defined?(LcpRuby::VERSION) ? LcpRuby::VERSION : "unknown")
+  manifest = {
+    manifest_version: 1,
+    generated_at: Time.now.iso8601,
+    lcp_ruby_version: lcp_ruby_version,
+    preset: preset,
+    requested_features: requested_features,
+    expanded_features: features.dup,
+    results: []
+  }
+
+  # Feature generators run as subprocesses (default `generate` — no
+  # `inline:`). The `inline: true` strategy was reverted because
+  # `Rails::Command.invoke` requires `Rails.application` which is not
+  # available during `rails new` template execution (the host app is
+  # still being scaffolded). See D8 in
+  # docs/design/generator_prerequisites_registry.md for the full
+  # decision history.
+  #
+  # Subprocess invocation has a known quirk: Thor::Group catches
+  # `Thor::Error` inside `start` and the subprocess exits 0 even on
+  # prereq violations. Exit code is unreliable. Instead, we ask whether
+  # the feature's `provides_models` files actually landed — that's the
+  # authoritative success signal.
+  #
+  # `provides_models` per feature is duplicated here from
+  # `LcpRuby::Generators::FeatureRegistry::FEATURES`. We can't `require`
+  # the registry from this template — it runs in `rails new`'s scaffold
+  # context where Bundler hasn't yet loaded the lcp_ruby gem's load
+  # paths. A drift test in feature_registry_spec.rb catches mismatches.
+  feature_provides = {
+    "install_auth"        => %w[user],
+    "custom_fields"       => %w[custom_field_definition],
+    "export"              => %w[export_log export_profile],
+    "import"              => %w[import_row import_profile],
+    "batch_operations"    => %w[batch_operation batch_operation_item],
+    "role_model"          => %w[role],
+    "permission_source"   => %w[permission_config],
+    "groups"              => %w[group group_membership group_role_mapping],
+    "auditing"            => %w[audit_log],
+    "monitoring"          => %w[lcp_error_log],
+    "saved_filters"       => %w[saved_filter],
+    "pages"               => %w[page_config],
+    "background_jobs"     => %w[job_execution],
+    "workflow_definition" => %w[workflow_definition],
+    "workflow_approvals"  => %w[workflow_approval_request workflow_approval_step workflow_approval_task],
+    "workflow_audit_log"  => %w[workflow_audit_log],
+    "gapfree_sequences"   => %w[gapfree_sequence],
+    "api_tokens"          => %w[api_token],
+    "oidc_role_mappings"  => %w[oidc_role_mapping]
+  }.freeze
+
+  feature_installed = lambda do |feat|
+    models = feature_provides[feat] || []
+    next true if models.empty?
+    models_dir = File.join(destination_root, "config/lcp_ruby/models")
+    models.all? do |name|
+      %w[rb yml].any? { |ext| File.exist?(File.join(models_dir, "#{name}.#{ext}")) }
+    end
+  end
+
+  features.each do |feature|
+    args = FORMAT_AWARE.include?(feature) ? [ "--format=#{format}" ] : []
+
+    # `abort_on_failure: false` so a hard subprocess crash (e.g. file
+    # permission error) doesn't kill the whole template — we want all
+    # results recorded, not the first crash to take down the manifest.
+    generate "lcp_ruby:#{feature}", *args, abort_on_failure: false
+
+    if feature_installed.call(feature)
+      manifest[:results] << { feature: feature, status: "success" }
+    else
+      hint = "generator did not produce expected model files (check output above for Thor::Error / prerequisite violation)"
+      say_status :error, "lcp_ruby:#{feature} failed: #{hint}", :red
+      manifest[:results] << { feature: feature, status: "failed", error: hint }
+    end
+  end
+
+  create_file "tmp/lcp_ruby/install_manifest.json", JSON.pretty_generate(manifest)
+
+  # Prepare database
+  rails_command "db:prepare"
+end