collavre 0.1.0

data/app/javascript/modules/slide_view.js

@@ -0,0 +1,163 @@
+import { createSubscription } from '../services/cable'
+
+document.addEventListener('DOMContentLoaded', function() {
+  var container = document.getElementById('slide-view');
+  if (!container) return;
+
+  var ids = container.dataset.slideIds.split(',').map(function(id) { return parseInt(id, 10); });
+  var index = parseInt(container.dataset.initialIndex || '0', 10);
+  var rootId = container.dataset.rootId;
+  var contentEl = document.getElementById('slide-content');
+  var swipeArea = document.getElementById('slide-swipe');
+  var counterEl = document.getElementById('slide-counter');
+  var linkEl = document.getElementById('slide-goto');
+  var captionEl = document.getElementById('slide-caption');
+  var timerEl = document.getElementById('slide-timer');
+  var startX = null;
+  var slideSubscription = null;
+  var lastScrollLeft = 0;
+  var timerStart = null;
+  var timerInterval = null;
+
+  if (index > 0) {
+    load(index, false);
+  } else {
+    updateUrl(index);
+  }
+
+  function updateUrl(idx) {
+    var url = new URL(window.location);
+    url.searchParams.set('slide', idx);
+    history.replaceState(null, '', url);
+  }
+
+  function load(idx, broadcast) {
+    if (idx < 0 || idx >= ids.length) return;
+    index = idx;
+    updateUrl(index);
+    if (counterEl) {
+      counterEl.textContent = (index + 1) + ' / ' + ids.length;
+    }
+    if (linkEl) {
+      linkEl.href = '/creatives/' + ids[index];
+    }
+    var url = '/creatives/' + ids[index] + '.json';
+    if (rootId) {
+      url += '?root_id=' + rootId;
+    }
+    fetch(url)
+      .then(function(r) { return r.json(); })
+      .then(function(data) {
+        var depth = data.depth || 1;
+        var tag = 'div';
+        if (depth === 1) {
+          tag = 'h1';
+        } else if (depth === 2) {
+          tag = 'h2';
+        } else if (depth === 3) {
+          tag = 'h3';
+        }
+        contentEl.innerHTML = '';
+        var el = document.createElement(tag);
+        el.innerHTML = data.description;
+        contentEl.appendChild(el);
+        if (captionEl) {
+          captionEl.textContent = data.prompt || '';
+        }
+        requestAnimationFrame(function() {
+          container.scrollLeft = 0;
+          container.scrollTop = 0;
+          lastScrollLeft = 0;
+        });
+      });
+    if (broadcast && slideSubscription) {
+      slideSubscription.perform('change', { index: index });
+    }
+  }
+
+  function updateTimer() {
+    if (!timerEl || timerStart === null) return;
+    var elapsedSeconds = Math.floor((Date.now() - timerStart) / 1000);
+    var minutes = Math.floor(elapsedSeconds / 60);
+    var seconds = elapsedSeconds % 60;
+    var formattedMinutes = minutes.toString().padStart(2, '0');
+    var formattedSeconds = seconds.toString().padStart(2, '0');
+    timerEl.textContent = formattedMinutes + ':' + formattedSeconds;
+  }
+
+  function startTimer() {
+    if (!timerEl) return;
+    timerStart = Date.now();
+    updateTimer();
+    if (timerInterval) {
+      clearInterval(timerInterval);
+    }
+    timerInterval = setInterval(updateTimer, 1000);
+  }
+
+  if (rootId) {
+    slideSubscription = createSubscription(
+      { channel: 'SlideViewChannel', root_id: rootId },
+      {
+        received: function(data) {
+          if (typeof data.index === 'number' && data.index !== index) {
+            load(data.index, false);
+          }
+        }
+      }
+    );
+    // broadcast initial state
+    slideSubscription.perform('change', { index: index });
+  }
+
+  if (swipeArea) {
+    swipeArea.addEventListener('touchstart', function(e) {
+      startX = e.touches[0].clientX;
+    });
+
+    swipeArea.addEventListener('touchend', function(e) {
+      if (startX === null) return;
+      var dx = e.changedTouches[0].clientX - startX;
+      if (Math.abs(dx) > 30) {
+        if (dx < 0) {
+          load(index + 1, true);
+        } else {
+          load(index - 1, true);
+        }
+      }
+      startX = null;
+    });
+  }
+
+  if (counterEl) {
+    counterEl.textContent = (index + 1) + ' / ' + ids.length;
+  }
+  if (linkEl) {
+    linkEl.href = '/creatives/' + ids[index];
+  }
+
+  startTimer();
+
+  window.addEventListener('keydown', function(e) {
+    var key = e.key || e.keyCode;
+    if (key === 'ArrowRight' || key === 39) {
+      e.preventDefault();
+      load(index + 1, true);
+    } else if (key === 'ArrowLeft' || key === 37) {
+      e.preventDefault();
+      load(index - 1, true);
+    }
+  });
+
+  container.addEventListener('scroll', function() {
+    if (container.scrollWidth <= container.clientWidth) return;
+    var max = container.scrollWidth - container.clientWidth;
+    var left = container.scrollLeft;
+    if (left === 0 && lastScrollLeft > 0) {
+      load(index - 1, true);
+    } else if (left >= max && lastScrollLeft < max) {
+      load(index + 1, true);
+    }
+    lastScrollLeft = left;
+  });
+});

data/app/javascript/services/cable.js

@@ -0,0 +1,32 @@
+import { createConsumer as actionCableCreateConsumer } from '@rails/actioncable'
+
+let singletonConsumer
+
+export function createConsumer(...args) {
+  if (!singletonConsumer) {
+    singletonConsumer = actionCableCreateConsumer(...args)
+  } else if (args.length > 0) {
+    console.warn(
+      '[ActionCable] Ignoring createConsumer arguments because a singleton consumer already exists.',
+    )
+  }
+
+  return singletonConsumer
+}
+
+export function createSubscription(identifier, callbacks = {}) {
+  return createConsumer().subscriptions.create(identifier, callbacks)
+}
+
+export function resetConsumer() {
+  if (singletonConsumer) {
+    singletonConsumer.disconnect()
+    singletonConsumer = null
+  }
+}
+
+export default {
+  createConsumer,
+  createSubscription,
+  resetConsumer,
+}

data/app/javascript/slide_view.js

@@ -0,0 +1,2 @@
+// Entry point for slide view
+import './modules/slide_view'

data/app/javascript/utils/caret_position.js

@@ -0,0 +1,42 @@
+export function getCaretClientRect(input) {
+  if (!input || typeof input.selectionStart !== 'number') return null
+
+  const selectionIndex = input.selectionStart
+  const computed = window.getComputedStyle(input)
+  const div = document.createElement('div')
+  const properties = [
+    'fontFamily', 'fontSize', 'fontWeight', 'fontStyle', 'letterSpacing',
+    'textTransform', 'textRendering', 'textAlign', 'paddingTop', 'paddingRight',
+    'paddingBottom', 'paddingLeft', 'borderTopWidth', 'borderRightWidth',
+    'borderBottomWidth', 'borderLeftWidth', 'lineHeight', 'whiteSpace', 'wordBreak'
+  ]
+
+  properties.forEach((prop) => {
+    div.style[prop] = computed[prop]
+  })
+
+  const rect = input.getBoundingClientRect()
+  div.style.position = 'absolute'
+  div.style.left = `${rect.left + window.scrollX}px`
+  div.style.top = `${rect.top + window.scrollY}px`
+  div.style.whiteSpace = 'pre-wrap'
+  div.style.wordWrap = 'break-word'
+  div.style.visibility = 'hidden'
+  div.style.boxSizing = 'border-box'
+  div.style.width = `${input.clientWidth}px`
+  div.style.minHeight = `${input.clientHeight}px`
+
+  const before = document.createTextNode(input.value.slice(0, selectionIndex))
+  const marker = document.createElement('span')
+  marker.textContent = '\u200b'
+
+  div.appendChild(before)
+  div.appendChild(marker)
+
+  document.body.appendChild(div)
+  div.scrollTop = input.scrollTop
+  const caretRect = marker.getBoundingClientRect()
+  document.body.removeChild(div)
+
+  return caretRect
+}

data/app/javascript/utils/clipboard.js

@@ -0,0 +1,40 @@
+var Plan42 = (typeof window !== 'undefined') ? (window.Plan42 || (window.Plan42 = {})) : {};
+
+function fallbackCopyText(text) {
+    return new Promise(function(resolve, reject) {
+        var temp = document.createElement('textarea');
+        temp.value = text;
+        temp.setAttribute('readonly', '');
+        temp.style.position = 'fixed';
+        temp.style.opacity = '0';
+        temp.style.pointerEvents = 'none';
+        document.body.appendChild(temp);
+        var succeeded = false;
+        try {
+            temp.focus();
+            temp.select();
+            succeeded = document.execCommand('copy');
+        } catch (err) {
+            succeeded = false;
+        }
+        document.body.removeChild(temp);
+        if (succeeded) {
+            resolve();
+        } else {
+            reject();
+        }
+    });
+}
+
+function copyTextToClipboard(text) {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+        return navigator.clipboard.writeText(text).catch(function() {
+            return fallbackCopyText(text);
+        });
+    }
+    return fallbackCopyText(text);
+}
+
+Plan42.copyTextToClipboard = copyTextToClipboard;
+
+export { copyTextToClipboard };

data/app/jobs/collavre/ai_agent_job.rb

@@ -0,0 +1,27 @@
+module Collavre
+class AiAgentJob < ApplicationJob
+  queue_as :default
+
+  def perform(agent_id, event_name, context)
+    agent = User.find(agent_id)
+
+    # Create Task
+    task = Task.create!(
+      name: "Response to #{event_name}",
+      status: "running",
+      trigger_event_name: event_name,
+      trigger_event_payload: context,
+      agent: agent
+    )
+
+    begin
+      AiAgentService.new(task).call
+      task.update!(status: "done")
+    rescue StandardError => e
+      task.update!(status: "failed")
+      Rails.logger.error("AiAgentJob failed for task #{task.id}: #{e.message}")
+      raise e
+    end
+  end
+end
+end

data/app/jobs/collavre/inbox_summary_job.rb

@@ -0,0 +1,24 @@
+module Collavre
+class InboxSummaryJob < ApplicationJob
+  queue_as :default
+
+  def perform
+    Rails.logger.info("Running InboxSummaryJob")
+    User.find_each do |user|
+      if user.notifications_enabled == false
+        Rails.logger.info("Skipping inbox summary for #{user.email} because notifications are disabled")
+        next
+      end
+
+      items = InboxItem.where(owner: user, state: "new").order(created_at: :desc).limit(10)
+      if items.empty?
+        Rails.logger.info("No new inbox items for #{user.email}")
+        next
+      end
+
+      Rails.logger.info("Sending inbox summary to #{user.email} with #{items.count} items")
+      Collavre::InboxMailer.with(user: user, items: items).daily_summary.deliver_now
+    end
+  end
+end
+end

data/app/jobs/collavre/notion_export_job.rb

@@ -0,0 +1,30 @@
+module Collavre
+class NotionExportJob < ApplicationJob
+  queue_as :default
+
+  def perform(creative, notion_account, parent_page_id = nil)
+    service = NotionService.new(user: notion_account.user)
+
+    begin
+      # Export the creative tree to Notion
+      link = service.sync_creative(creative, parent_page_id: parent_page_id)
+
+      Rails.logger.info("Successfully exported creative #{creative.id} to Notion page #{link.page_id}")
+
+      # You could add broadcast/notification logic here if needed
+      # ActionCable.server.broadcast("user_#{notion_account.user.id}", {
+      #   type: 'notion_export_complete',
+      #   creative_id: creative.id,
+      #   page_url: link.page_url
+      # })
+
+    rescue NotionError => e
+      Rails.logger.error("Notion export failed for creative #{creative.id}: #{e.message}")
+      raise e
+    rescue StandardError => e
+      Rails.logger.error("Unexpected error during Notion export for creative #{creative.id}: #{e.message}")
+      raise e
+    end
+  end
+end
+end

data/app/jobs/collavre/notion_sync_job.rb

@@ -0,0 +1,48 @@
+module Collavre
+class NotionSyncJob < ApplicationJob
+  queue_as :default
+
+  def perform(creative, notion_account, page_id)
+    service = NotionService.new(user: notion_account.user)
+
+    begin
+      # Find the existing link
+      link = NotionPageLink.find_by(
+        creative: creative,
+        notion_account: notion_account,
+        page_id: page_id
+      )
+
+      unless link
+        Rails.logger.error("No Notion page link found for creative #{creative.id} and page #{page_id}")
+        return
+      end
+
+      # Update the existing Notion page with children as blocks
+      title = ActionController::Base.helpers.strip_tags(creative.description).strip.presence || "Untitled Creative"
+      children = creative.children.to_a
+      Rails.logger.info("NotionSyncJob: Syncing creative #{creative.id} as page title with #{children.count} children as blocks")
+      blocks = children.any? ? NotionCreativeExporter.new(creative).export_tree_blocks(children, 1, 0) : []
+
+      properties = {
+        title: {
+          title: [ { text: { content: title } } ]
+        }
+      }
+
+      service.update_page(page_id, properties: properties, blocks: blocks)
+      link.update!(page_title: title)
+      link.mark_synced!
+
+      Rails.logger.info("Successfully synced creative #{creative.id} to Notion page #{page_id}")
+
+    rescue NotionError => e
+      Rails.logger.error("Notion sync failed for creative #{creative.id}: #{e.message}")
+      raise e
+    rescue StandardError => e
+      Rails.logger.error("Unexpected error during Notion sync for creative #{creative.id}: #{e.message}")
+      raise e
+    end
+  end
+end
+end

data/app/jobs/collavre/permission_cache_cleanup_job.rb

@@ -0,0 +1,36 @@
+module Collavre
+class PermissionCacheCleanupJob < ApplicationJob
+  queue_as :default
+
+  BATCH_SIZE = 1000
+
+  def perform
+    orphaned_by_creative = delete_in_batches(
+      CreativeSharesCache.where.not(creative_id: Creative.select(:id))
+    )
+
+    orphaned_by_user = delete_in_batches(
+      CreativeSharesCache.where.not(user_id: nil).where.not(user_id: User.select(:id))
+    )
+
+    orphaned_by_share = delete_in_batches(
+      CreativeSharesCache.where.not(source_share_id: nil).where.not(source_share_id: CreativeShare.select(:id))
+    )
+
+    Rails.logger.info(
+      "[PermissionCacheCleanupJob] Cleaned up orphaned cache rows: " \
+      "creative=#{orphaned_by_creative}, user=#{orphaned_by_user}, share=#{orphaned_by_share}"
+    )
+  end
+
+  private
+
+  def delete_in_batches(scope)
+    total_deleted = 0
+    scope.in_batches(of: BATCH_SIZE) do |batch|
+      total_deleted += batch.delete_all
+    end
+    total_deleted
+  end
+end
+end

data/app/jobs/collavre/permission_cache_job.rb

@@ -0,0 +1,71 @@
+module Collavre
+class PermissionCacheJob < ApplicationJob
+  queue_as :authz
+
+  discard_on ActiveJob::DeserializationError
+  discard_on ActiveRecord::RecordNotFound
+
+  def perform(operation, **args)
+    if operation.nil?
+      Rails.logger.error("[PermissionCacheJob] Received nil operation, args: #{args.inspect}")
+      return
+    end
+
+    case operation.to_sym
+    when :cache_owner
+      cache_owner(args[:creative_id])
+    when :update_owner
+      update_owner(args[:creative_id], args[:old_user_id], args[:new_user_id])
+    when :rebuild_for_creative
+      rebuild_for_creative(args[:creative_id])
+    when :propagate_share
+      propagate_share(args[:creative_share_id])
+    when :remove_share
+      remove_share(args[:creative_share_id], args[:creative_id], args[:user_id])
+    when :rebuild_user_cache_for_subtree
+      rebuild_user_cache_for_subtree(args[:creative_id], args[:user_id])
+    else
+      Rails.logger.error("[PermissionCacheJob] Unknown operation: #{operation.inspect}, args: #{args.inspect}")
+    end
+  end
+
+  private
+
+  def cache_owner(creative_id)
+    creative = Creative.find_by(id: creative_id)
+    return unless creative
+    Creatives::PermissionCacheBuilder.cache_owner(creative)
+  end
+
+  def update_owner(creative_id, old_user_id, new_user_id)
+    creative = Creative.find_by(id: creative_id)
+    return unless creative
+    Creatives::PermissionCacheBuilder.update_owner(creative, old_user_id, new_user_id)
+  end
+
+  def rebuild_for_creative(creative_id)
+    creative = Creative.find_by(id: creative_id)
+    return unless creative
+    Creatives::PermissionCacheBuilder.rebuild_for_creative(creative)
+  end
+
+  def propagate_share(creative_share_id)
+    share = CreativeShare.find_by(id: creative_share_id)
+    return unless share
+    Creatives::PermissionCacheBuilder.propagate_share(share)
+  end
+
+  def remove_share(creative_share_id, creative_id, user_id)
+    CreativeSharesCache.where(source_share_id: creative_share_id).delete_all
+    creative = Creative.find_by(id: creative_id)
+    return unless creative
+    Creatives::PermissionCacheBuilder.rebuild_from_ancestors_for_user(creative, user_id)
+  end
+
+  def rebuild_user_cache_for_subtree(creative_id, user_id)
+    creative = Creative.find_by(id: creative_id)
+    return unless creative
+    Creatives::PermissionCacheBuilder.rebuild_user_cache_for_subtree(creative, user_id)
+  end
+end
+end

data/app/jobs/collavre/push_notification_job.rb

@@ -0,0 +1,86 @@
+module Collavre
+class PushNotificationJob < ApplicationJob
+  queue_as :default
+
+  def perform(user_id, message:, link: nil)
+    tokens = Device.where(user_id: user_id).pluck(:fcm_token)
+    return if tokens.empty?
+
+    service = Rails.application.config.x.fcm_service
+    project_id = Rails.application.config.x.fcm_project_id
+
+    if service && project_id
+      tokens.each do |token|
+        send_v1(service, project_id, token, message, link)
+      end
+    elsif (client = Rails.application.config.x.fcm_client)
+      client.send(tokens, {
+        notification: {
+          title: "새 알림",
+          body: message,
+          click_action: link
+        }
+      })
+    end
+  end
+
+  private
+
+  def send_v1(service, project_id, token, message, link)
+    notification = Google::Apis::FcmV1::Notification.new(
+      title: "새 알림",
+      body: message
+    )
+
+    webpush = Google::Apis::FcmV1::WebpushConfig.new(
+      fcm_options: Google::Apis::FcmV1::WebpushFcmOptions.new(link: link)
+    )
+
+    msg = Google::Apis::FcmV1::Message.new(
+      token: token,
+      notification: notification,
+      webpush: webpush,
+      data: { path: link }
+    )
+    Rails.logger.info("Sending push to token: #{token} with message: #{message} and link: #{link}")
+
+    request = Google::Apis::FcmV1::SendMessageRequest.new(message: msg)
+
+    begin
+      response = service.send_message("projects/#{project_id}", request)
+      Rails.logger.info("✅ Push sent successfully: #{token} #{response.inspect}")
+      response
+    rescue Google::Apis::ClientError => e
+      if invalid_registration_token?(e)
+        Rails.logger.warn("⚠️ Removing invalid FCM token: #{token} (#{e.message})")
+        Device.where(fcm_token: token).delete_all
+        nil
+      else
+        raise
+      end
+    end
+  end
+
+  def invalid_registration_token?(error)
+    status_code = error.respond_to?(:status_code) ? error.status_code : nil
+    return false unless status_code == 404
+
+    payload = parse_error_body(error.body)
+    contains_unregistered_detail?(payload)
+  end
+
+  def parse_error_body(body)
+    JSON.parse(body) if body.present?
+  rescue JSON::ParserError
+    nil
+  end
+
+  def contains_unregistered_detail?(body)
+    details = body&.dig("error", "details")
+    Array(details).any? do |detail|
+      detail["@type"] == "type.googleapis.com/google.firebase.fcm.v1.FcmError" &&
+        detail["errorCode"] == "UNREGISTERED"
+    end
+  end
+end
+end

data/app/mailers/collavre/application_mailer.rb

@@ -0,0 +1,17 @@
+module Collavre
+  class ApplicationMailer < ActionMailer::Base
+    default from: ENV.fetch("DEFAULT_MAILER_FROM", "no-reply@example.com")
+    layout "mailer"
+
+    private
+
+    def extract_body(email)
+      if email.multipart?
+        part = email.text_part || email.html_part
+        part&.body&.decoded.to_s
+      else
+        email.body.decoded
+      end
+    end
+  end
+end

data/app/mailers/collavre/creative_mailer.rb

@@ -0,0 +1,9 @@
+module Collavre
+class CreativeMailer < ApplicationMailer
+  # Subject can be set in your I18n file at config/locales/en.yml
+  # with the following lookup:
+  #
+  #   en.creative_mailer.in_stock.subject
+  #
+end
+end

data/app/mailers/collavre/email_verification_mailer.rb

@@ -0,0 +1,20 @@
+module Collavre
+  class EmailVerificationMailer < ApplicationMailer
+    helper Collavre::Engine.routes.url_helpers
+
+    def verify(user)
+      @user = user
+      mail to: user.email, subject: I18n.t("collavre.user_mailer.email_verification.subject")
+    end
+
+    private
+
+    def verify_url(token:)
+      collavre_engine_url_helpers.email_verification_url(token: token)
+    end
+
+    def collavre_engine_url_helpers
+      Collavre::Engine.routes.url_helpers
+    end
+  end
+end

data/app/mailers/collavre/inbox_mailer.rb

@@ -0,0 +1,19 @@
+module Collavre
+  class InboxMailer < ApplicationMailer
+    def daily_summary
+      @user = params[:user]
+      @items = params[:items]
+      locale = @user.locale.presence || I18n.default_locale.to_s
+      email = I18n.with_locale(locale) do
+        mail to: @user.email, subject: I18n.t("collavre.inbox_mailer.daily_summary.subject")
+      end
+      Collavre::Email.create!(
+        user: @user,
+        email: @user.email,
+        subject: email.subject,
+        body: extract_body(email),
+        event: :inbox_summary
+      )
+    end
+  end
+end