collavre 0.3.2 → 0.5.0

data/app/jobs/collavre/cron_action_job.rb

@@ -6,25 +6,35 @@ module Collavre
   # agent orchestration pipeline.
   #
   # Created dynamically via the cron_create MCP tool.
+  # topic_id can be nil for the main topic.
   class CronActionJob < ApplicationJob
     queue_as :default
 
     def perform(creative_id:, topic_id:, agent_id:, message:)
       creative = Creative.find_by(id: creative_id)
-      topic = Topic.find_by(id: topic_id)
       agent = User.find_by(id: agent_id)
 
-      unless creative && topic && agent
+      unless creative && agent
         Rails.logger.warn(
-          "[CronActionJob] Skipping: creative=#{creative_id} topic=#{topic_id} agent=#{agent_id} - record not found"
+          "[CronActionJob] Skipping: creative=#{creative_id} agent=#{agent_id} - record not found"
         )
         return
       end
 
+      # topic_id nil means main topic; otherwise look up the topic
+      topic = nil
+      if topic_id.present?
+        topic = Topic.find_by(id: topic_id)
+        unless topic
+          Rails.logger.warn("[CronActionJob] Skipping: topic=#{topic_id} not found")
+          return
+        end
+      end
+
       comment = creative.comments.create!(
         content: message,
         user: agent,
-        topic_id: topic.id,
+        topic_id: topic&.id,
         private: false
       )
 
@@ -40,14 +50,16 @@ module Collavre
           description: creative.description
         },
         topic: {
-          id: topic.id
+          id: topic&.id
         },
         chat: {
           content: comment.content
         }
       })
 
-      Rails.logger.info("[CronActionJob] Posted cron message to creative #{creative_id}, topic #{topic_id}")
+      Rails.logger.info(
+        "[CronActionJob] Posted cron message to creative #{creative_id}, topic #{topic_id || 'main'}"
+      )
     end
   end
 end

data/app/jobs/collavre/cron_scheduler_job.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Collavre
+  # CronSchedulerJob is a self-scheduling job that runs every minute and
+  # picks up dynamically-created recurring tasks (static: false) whose
+  # cron schedule matches the current minute. For each match it enqueues
+  # the target job (e.g. CronActionJob).
+  #
+  # This exists because Solid Queue's built-in Scheduler only processes
+  # static (config-defined) recurring tasks — dynamic ones created via
+  # cron_create are ignored by the Scheduler.
+  #
+  # Self-scheduling: after each run, the job re-enqueues itself with
+  # `wait: 1.minute`. Boot-time scheduling is handled by the engine
+  # initializer (see collavre/engine.rb).
+  #
+  # Duplicate-execution guard: uses Rails.cache with a per-task, per-minute
+  # key so that even if this job runs twice in the same minute window,
+  # each task fires at most once. (This cache is process-local and acceptable
+  # since CronSchedulerJob runs in a single SQ worker process.)
+  #
+  # Reschedule guard: uses SolidQueue::Job table (DB-based) to prevent
+  # duplicate scheduler chains — works across all environments without
+  # shared cache infrastructure.
+  class CronSchedulerJob < ApplicationJob
+    queue_as :default
+
+    def perform
+      now = Time.current
+      dynamic_tasks = SolidQueue::RecurringTask.where(static: false)
+
+      dynamic_tasks.find_each do |task|
+        next unless schedule_matches?(task, now)
+        next if already_dispatched?(task, now)
+
+        enqueue_task(task)
+        mark_dispatched(task, now)
+      end
+    ensure
+      reschedule
+    end
+
+    private
+
+    def schedule_matches?(task, time)
+      cron = Fugit.parse(task.schedule)
+      return false unless cron.is_a?(Fugit::Cron)
+
+      # Truncate to the beginning of the current minute so that
+      # cron.match? works regardless of which second the job runs at.
+      minute_start = time.change(sec: 0)
+      cron.match?(minute_start)
+    end
+
+    def cache_key(task, time)
+      minute = time.strftime("%Y%m%d%H%M")
+      "cron_scheduler:#{task.key}:#{minute}"
+    end
+
+    def already_dispatched?(task, time)
+      Rails.cache.read(cache_key(task, time)).present?
+    end
+
+    def mark_dispatched(task, time)
+      Rails.cache.write(cache_key(task, time), true, expires_in: 2.minutes)
+    end
+
+    def enqueue_task(task)
+      job_class = task.class_name.safe_constantize
+      unless job_class
+        Rails.logger.warn("[CronScheduler] Unknown job class: #{task.class_name} for task #{task.key}")
+        return
+      end
+
+      args = task.arguments || []
+      if args.is_a?(Array) && args.first.is_a?(Hash)
+        job_class.perform_later(**args.first.symbolize_keys)
+      elsif args.is_a?(Array)
+        job_class.perform_later(*args)
+      else
+        job_class.perform_later
+      end
+
+      Rails.logger.info("[CronScheduler] Enqueued #{task.class_name} for task #{task.key}")
+    rescue StandardError => e
+      Rails.logger.error("[CronScheduler] Failed to enqueue #{task.key}: #{e.message}")
+    end
+
+    def reschedule
+      # DB-based guard: skip if a CronSchedulerJob is already pending
+      return if pending_scheduler_exists?
+
+      self.class.set(wait: 1.minute).perform_later
+      Rails.logger.info("[CronScheduler] Rescheduled for next minute")
+    end
+
+    def pending_scheduler_exists?
+      scope = SolidQueue::Job
+        .where(class_name: self.class.name)
+        .where(finished_at: nil)
+
+      # Exclude the currently running job to avoid blocking our own reschedule
+      scope = scope.where.not(id: provider_job_id) if provider_job_id.present?
+
+      # Exclude failed jobs — they won't run again without manual retry
+      failed_job_ids = SolidQueue::FailedExecution.pluck(:job_id)
+      scope = scope.where.not(id: failed_job_ids) if failed_job_ids.any?
+
+      scope.exists?
+    end
+  end
+end

data/app/models/collavre/comment/approvable.rb

@@ -0,0 +1,50 @@
+module Collavre
+  class Comment < ApplicationRecord
+    module Approvable
+      extend ActiveSupport::Concern
+
+      def can_be_approved_by?(user)
+        approval_status(user) == :ok
+      end
+
+      def approval_status(user)
+        return :not_allowed unless user
+
+        if action.blank?
+          return :not_allowed unless approver_id == user&.id
+          return :missing_action
+        end
+
+        begin
+          payload = JSON.parse(action)
+        rescue JSON::ParserError
+          return :invalid_action_format
+        end
+        return :invalid_action_format unless payload.is_a?(Hash)
+
+        actions = Array(payload["actions"])
+        actions = [ payload ] if actions.empty?
+
+        requires_admin = actions.any? do |item|
+          next false unless item.is_a?(Hash)
+          action_type = item["action"] || item["type"]
+          action_type == "approve_tool"
+        end
+
+        if requires_admin && SystemSetting.mcp_tool_approval_required?
+          return user.system_admin? ? :ok : :admin_required
+        end
+
+        return :missing_approver if approver_id.blank?
+        return :not_allowed unless approver_id == user&.id
+
+        :ok
+      end
+
+      def parsed_action_tool_name
+        parsed = JSON.parse(action) rescue nil
+        parsed&.dig("tool_name") || "unknown"
+      end
+    end
+  end
+end

data/app/models/collavre/comment/broadcastable.rb

@@ -0,0 +1,119 @@
+module Collavre
+  class Comment < ApplicationRecord
+    module Broadcastable
+      extend ActiveSupport::Concern
+
+      included do
+        after_create_commit :broadcast_create, :broadcast_badges
+        after_update_commit :broadcast_update
+        after_destroy_commit :broadcast_destroy, :broadcast_badges
+      end
+
+      module ClassMethods
+        def broadcast_badges(creative)
+          origin = creative.effective_origin
+          users = [ origin.user ].compact + origin.all_shared_users(:feedback).map(&:user)
+          users.compact!
+          users.uniq!
+          return if users.empty?
+
+          user_ids = users.map(&:id)
+
+          pointers = CommentReadPointer.where(user_id: user_ids, creative: origin).index_by(&:user_id)
+          present_user_ids = CommentPresenceStore.list(origin.id)
+
+          public_count = origin.comments.where(private: false).count
+          private_counts = origin.comments
+            .where(private: true, user_id: user_ids)
+            .group(:user_id)
+            .count
+
+          last_read_ids = pointers.transform_values { |p| p.last_read_comment_id || 0 }
+
+          unread_public_by_threshold = {}
+          last_read_ids.values.uniq.each do |threshold|
+            unread_public_by_threshold[threshold] = origin.comments
+              .where(private: false)
+              .where("comments.id > ?", threshold)
+              .count
+          end
+
+          unread_private_counts = {}
+          user_ids.each do |uid|
+            threshold = last_read_ids[uid] || 0
+            unread_private_counts[uid] = origin.comments
+              .where(private: true, user_id: uid)
+              .where("comments.id > ?", threshold)
+              .count
+          end
+
+          users.each do |u|
+            user_private_count = private_counts[u.id] || 0
+            total_count = public_count + user_private_count
+
+            threshold = last_read_ids[u.id] || 0
+            unread_public = unread_public_by_threshold[threshold] || 0
+            unread_private = unread_private_counts[u.id] || 0
+            unread_count = unread_public + unread_private
+
+            unread_count = 0 if present_user_ids.include?(u.id)
+
+            Turbo::StreamsChannel.broadcast_replace_to(
+              [ u, origin, :comment_badge ],
+              target: "comment-badge-#{origin.id}",
+              partial: "inbox/badge_component/count",
+              locals: {
+                count: unread_count,
+                badge_id: "comment-badge-#{origin.id}",
+                show_zero: total_count.positive?
+              }
+            )
+          end
+        end
+
+        def broadcast_badge(creative, user)
+          origin = creative.effective_origin
+          visible_comments = origin.comments.where("comments.private = ? OR comments.user_id = ?", false, user.id)
+          comments_count = visible_comments.count
+          pointer = CommentReadPointer.find_by(user: user, creative: origin)
+          last_read_id = pointer&.last_read_comment_id
+          unread_scope = last_read_id ? visible_comments.where("comments.id > ?", last_read_id) : visible_comments
+          unread_count = unread_scope.count
+          unread_count = 0 if CommentPresenceStore.list(origin.id).include?(user.id)
+          Turbo::StreamsChannel.broadcast_replace_to(
+            [ user, origin, :comment_badge ],
+            target: "comment-badge-#{origin.id}",
+            partial: "inbox/badge_component/count",
+            locals: {
+              count: unread_count,
+              badge_id: "comment-badge-#{origin.id}",
+              show_zero: comments_count.positive?
+            }
+          )
+        end
+      end
+
+      private
+
+      def broadcast_create
+        return if private?
+        broadcast_append_later_to([ creative, :comments ], target: "comments-list", partial: "collavre/comments/comment")
+      end
+
+      def broadcast_update
+        return if private?
+        broadcast_replace_later_to([ creative, :comments ], partial: "collavre/comments/comment")
+      end
+
+      def broadcast_destroy
+        return if private? || !creative
+        broadcast_remove_to([ creative, :comments ])
+      end
+
+      def broadcast_badges
+        return unless creative
+        self.class.broadcast_badges(creative)
+      end
+    end
+  end
+end

data/app/models/collavre/comment/notifiable.rb

@@ -0,0 +1,111 @@
+module Collavre
+  class Comment < ApplicationRecord
+    module Notifiable
+      extend ActiveSupport::Concern
+
+      included do
+        after_create_commit :notify_write_users, :notify_mentions, :notify_approver
+      end
+
+      def mentioned_users
+        return Collavre.user_class.none unless user
+        emails = mentioned_emails - [ user.email.downcase ]
+        names = mentioned_names - [ user.name.downcase ]
+
+        origin = creative.effective_origin
+        mentionable_users = Collavre.user_class.mentionable_for(origin)
+
+        scope = Collavre.user_class.none
+        scope = scope.or(mentionable_users.where(email: emails)) if emails.any?
+        scope = scope.or(mentionable_users.where("LOWER(name) IN (?)", names)) if names.any?
+        scope
+      end
+
+      private
+
+      def create_inbox_item(owner, key, params = {})
+        origin = creative&.effective_origin
+        metadata = params.to_h.stringify_keys
+        metadata["comment_id"] = id
+        metadata["creative_id"] = origin&.id
+
+        InboxItem.create!(
+          owner: owner,
+          message_key: key,
+          message_params: metadata,
+          comment: self,
+          creative: origin,
+          link: Collavre::Engine.routes.url_helpers.creative_comment_url(
+            creative,
+            self,
+            Rails.application.config.action_mailer.default_url_options
+          )
+        )
+      end
+
+      def streaming_placeholder?
+        user&.ai_user? && content == STREAMING_PLACEHOLDER_CONTENT
+      end
+
+      def mentioned_emails
+        return [] unless content
+        content.scan(/@([\w.\-+]+@[a-zA-Z0-9\-.]+\.[a-zA-Z]{2,})/)
+               .flatten
+               .map(&:downcase)
+               .uniq
+      end
+
+      def mentioned_names
+        return [] unless content
+        content.scan(/@([^:]+):/)
+               .flatten
+               .map(&:downcase)
+               .uniq
+      end
+
+      def notify_write_users
+        return if private? || !user
+        return if streaming_placeholder?
+        base_creative = creative.effective_origin
+        present_ids = CommentPresenceStore.list(base_creative.id)
+        recipients = base_creative.all_shared_users(:write).map(&:user)
+        recipients << base_creative.user
+        recipients.compact!
+        recipients.uniq!
+        recipients.delete(user)
+        recipients -= mentioned_users.to_a
+        recipients.reject! { |u| present_ids.include?(u.id) }
+        recipients.each do |recipient|
+          create_inbox_item(
+            recipient,
+            "inbox.comment_added",
+            { user: user.display_name, comment: content, creative: creative_snippet }
+          )
+        end
+      end
+
+      def notify_mentions
+        return if private?
+        return if streaming_placeholder?
+        mentioned_users.each do |mentioned|
+          create_inbox_item(
+            mentioned,
+            "inbox.user_mentioned",
+            { user: user.display_name, comment: content, creative: creative_snippet }
+          )
+        end
+      end
+
+      def notify_approver
+        return unless approver.present? && action.present?
+        return if approver == user
+
+        create_inbox_item(
+          approver,
+          "inbox.approval_requested",
+          { user: user&.display_name, tool_name: parsed_action_tool_name, creative: creative_snippet }
+        )
+      end
+    end
+  end
+end