collavre 0.24.0 → 0.25.0

data/app/javascript/controllers/creatives/__tests__/write_access_request_controller.test.js

@@ -0,0 +1,125 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+
+const csrfFetch = jest.fn()
+const alertDialog = jest.fn(() => Promise.resolve())
+
+jest.unstable_mockModule('../../../lib/api/csrf_fetch', () => ({
+  default: csrfFetch,
+}))
+jest.unstable_mockModule('../../../lib/utils/dialog', () => ({
+  alertDialog,
+}))
+
+const { Application } = await import('@hotwired/stimulus')
+const WriteAccessRequestController = (await import('../write_access_request_controller')).default
+
+describe('CreativesWriteAccessRequestController', () => {
+  const failureMessage = '권한을 요청하지 못했습니다.'
+  let application
+  let container
+  let button
+
+  function markup() {
+    return `
+      <div data-controller="creatives--write-access-request" data-creatives--write-access-request-url-value="/creatives/1/request_permission" data-creatives--write-access-request-failure-message-value="${failureMessage}">
+        <button type="button" data-creatives--write-access-request-target="button" data-action="click->creatives--write-access-request#request">Request write access</button>
+        <span data-creatives--write-access-request-target="pending" hidden>Access requested</span>
+      </div>
+    `
+  }
+
+  beforeEach(() => {
+    csrfFetch.mockReset()
+    alertDialog.mockClear()
+    document.body.innerHTML = markup()
+    container = document.querySelector('[data-controller="creatives--write-access-request"]')
+    button = container.querySelector('[data-creatives--write-access-request-target="button"]')
+
+    application = Application.start()
+    application.register('creatives--write-access-request', WriteAccessRequestController)
+  })
+
+  afterEach(() => {
+    application.stop()
+    document.body.innerHTML = ''
+  })
+
+  test('on success, hides the button and shows the pending pill', async () => {
+    csrfFetch.mockResolvedValue({ ok: true })
+
+    button.click()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(csrfFetch).toHaveBeenCalledWith('/creatives/1/request_permission', { method: 'POST' })
+    expect(button.hidden).toBe(true)
+    const pending = container.querySelector('[data-creatives--write-access-request-target="pending"]')
+    expect(pending.hidden).toBe(false)
+  })
+
+  test('on non-ok response, re-enables the button and does not show the pending pill', async () => {
+    csrfFetch.mockResolvedValue({ ok: false })
+
+    button.click()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(button.hidden).toBe(false)
+    expect(button.disabled).toBe(false)
+    const pending = container.querySelector('[data-creatives--write-access-request-target="pending"]')
+    expect(pending.hidden).toBe(true)
+    expect(alertDialog).toHaveBeenCalledWith(failureMessage)
+  })
+
+  test('on network error, re-enables the button', async () => {
+    csrfFetch.mockRejectedValue(new Error('network down'))
+
+    button.click()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(button.hidden).toBe(false)
+    expect(button.disabled).toBe(false)
+    expect(alertDialog).toHaveBeenCalledWith(failureMessage)
+  })
+
+  test('does not fall back to hardcoded copy when no localized failure message is rendered', async () => {
+    container.removeAttribute('data-creatives--write-access-request-failure-message-value')
+    csrfFetch.mockResolvedValue({ ok: false })
+
+    button.click()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(button.disabled).toBe(false)
+    expect(alertDialog).not.toHaveBeenCalled()
+  })
+
+  test('on a followed redirect to the sign-in page (expired session), navigates there instead of showing pending', async () => {
+    // fetch() follows redirects by default, so when the session has expired,
+    // Authentication#request_authentication redirects to the sign-in page and
+    // the browser lands on a 200 OK response for the login form itself. `ok`
+    // is therefore true even though no permission request was ever created —
+    // `redirected` is what actually distinguishes this from a real success.
+    const redirectSpy = jest
+      .spyOn(WriteAccessRequestController.prototype, 'redirectToSignIn')
+      .mockImplementation(() => {})
+
+    csrfFetch.mockResolvedValue({ ok: true, redirected: true, url: 'http://localhost/session/new' })
+
+    button.click()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(redirectSpy).toHaveBeenCalledWith('http://localhost/session/new')
+    expect(button.hidden).toBe(false)
+    const pending = container.querySelector('[data-creatives--write-access-request-target="pending"]')
+    expect(pending.hidden).toBe(true)
+
+    redirectSpy.mockRestore()
+  })
+})

data/app/javascript/controllers/creatives/select_mode_controller.js

@@ -1,6 +1,7 @@
 import { Controller } from '@hotwired/stimulus'
 import csrfFetch from '../../lib/api/csrf_fetch'
 import { confirmDialog } from '../../lib/utils/confirm_dialog'
+import { removeTreeElement } from '../../modules/creative_tree_dom'
 
 export default class extends Controller {
   static targets = [
@@ -102,9 +103,13 @@ export default class extends Controller {
       detail: { creativeIds: ids.map(String) }
     }))
 
+    // Route through the shared helper: it drops the enclosing <creative-tree-row>
+    // wrapper (removing only the inner .creative-tree left an empty wrapper behind,
+    // which reads as "still populated") and restores the empty-state placeholder
+    // once the last row is gone. The destroy broadcast excludes the initiating
+    // user, so nothing else repairs this window's DOM.
     ids.forEach((id) => {
-      const tree = document.getElementById(`creative-${id}`)
-      if (tree) tree.remove()
+      removeTreeElement(document.getElementById(`creative-${id}`))
     })
 
     this.clearSelection()

data/app/javascript/controllers/creatives/tree_controller.js

@@ -1,19 +1,34 @@
 import { Controller } from '@hotwired/stimulus'
 import { renderCreativeTree, appendCreativeNodes, dispatchCreativeTreeUpdated } from '../../creatives/tree_renderer'
 import { parseEmojis } from '../../utils/emoji_parser'
+import {
+  hideTreeEmptyState,
+  restoreTreeEmptyState,
+  PAGINATION_PENDING_ATTRIBUTE,
+} from '../../modules/creative_tree_empty_state'
 
 const TREE_RETRY_DELAYS_MS = [200, 600]
 
 export default class extends Controller {
   static values = {
     url: String,
-    emptyHtml: String,
+    // Neither fallback is an HTML string any more: showEmptyState() clones the
+    // server-rendered <template>, and the load-error fallback is a bare
+    // translated sentence the client wraps in a <p> itself. Reading markup back
+    // out of a data attribute and assigning it is an innerHTML sink as far as
+    // CodeQL (js/xss-through-dom) is concerned, and neither needs to be one.
+    errorText: String,
+    // Accessible name for a loading placeholder built by this controller.
+    // Renderers that do not provide a translated server placeholder must pass
+    // this value so extensions cannot expose a hardcoded label in another locale.
+    loadingText: String,
   }
 
   connect() {
     this.abortController = null
     this.loadingIndicator = null
     this._editing = false
+    this._reloadHoldCount = 0
     this._pagination = null
     this._sentinel = null
     this._sentinelObserver = null
@@ -27,10 +42,7 @@ export default class extends Controller {
       this._editing = false
       // Apply any pending sync data that was deferred while editing
       this._applyPendingSyncData()
-      if (this._pendingRefetch) {
-        this._pendingRefetch = false
-        this.debouncedLoad()
-      }
+      this._drainPendingReload()
     }
     document.documentElement.classList.remove('creative-alignment-ready')
     if (!this.hasCachedContent()) {
@@ -41,13 +53,7 @@ export default class extends Controller {
     this.element.addEventListener('creative-tree:updated', this.handleTreeUpdated)
     document.addEventListener('creative-editing:start', this._handleEditStart)
     document.addEventListener('creative-editing:stop', this._handleEditStop)
-    this._handleSyncRefetch = () => {
-      if (this._editing) {
-        this._pendingRefetch = true
-        return
-      }
-      this.debouncedLoad()
-    }
+    this._handleSyncRefetch = () => this.requestReload()
     document.addEventListener('creative-sync:refetch', this._handleSyncRefetch)
     this._setupArchiveToggle()
   }
@@ -141,7 +147,57 @@ export default class extends Controller {
 
   debouncedLoad() {
     if (this._debouncedLoadTimer) clearTimeout(this._debouncedLoadTimer)
-    this._debouncedLoadTimer = setTimeout(() => this.load(), 300)
+    this._debouncedLoadTimer = setTimeout(() => {
+      // Re-check rather than trusting the check requestReload() already made.
+      // Switching rows is a `creative-editing:stop` immediately followed by a
+      // `creative-editing:start`, so a refetch drained on the stop is still
+      // sitting in this debounce window when the next row opens — and load()
+      // replaces the whole container, which would take that row, the editor
+      // attached inside it and the unsaved draft out of the document. Re-pend
+      // instead of dropping it: the reload is still owed, just not yet safe.
+      if (this._editing || this._reloadHoldCount > 0) {
+        this._pendingRefetch = true
+        return
+      }
+      this.load()
+    }, 300)
+  }
+
+  // Editing-aware reload — the entry point for anything that wants the tree
+  // refetched in response to something that already happened elsewhere (the sync
+  // channel, an archive/unarchive that landed, a delete that promoted children to
+  // the root). load() replaces the whole container, which takes the row an open
+  // editor is attached to out of the document along with the unsaved draft inside
+  // it; those callers can land at any moment, including long after the user has
+  // moved on to editing a different row. So the reload waits for
+  // `creative-editing:stop`, which _handleEditStop drains.
+  //
+  // Call load() directly only for reloads the user just asked for and is waiting
+  // on (filter change, archive toggle), where re-rendering is the point.
+  requestReload() {
+    if (this._editing || this._reloadHoldCount > 0) {
+      this._pendingRefetch = true
+      return
+    }
+    this.debouncedLoad()
+  }
+
+  // Keep editing-aware reloads pending while an operation is between its local
+  // edit flush and its server response. The counter makes overlapping requests
+  // release independently without allowing an early reload between them.
+  beginReloadHold() {
+    this._reloadHoldCount += 1
+  }
+
+  endReloadHold() {
+    if (this._reloadHoldCount > 0) this._reloadHoldCount -= 1
+    this._drainPendingReload()
+  }
+
+  _drainPendingReload() {
+    if (!this._pendingRefetch || this._editing || this._reloadHoldCount > 0) return
+    this._pendingRefetch = false
+    this.debouncedLoad()
   }
 
   load() {
@@ -187,7 +243,7 @@ export default class extends Controller {
         }
         console.error(error)
         this.hideLoadingIndicator()
-        this.showEmptyState()
+        this.showErrorState()
       })
   }
 
@@ -221,6 +277,9 @@ export default class extends Controller {
     this._pagination = pagination || null
     if (!this._pagination || !this._pagination.has_more) return
     if (typeof IntersectionObserver === 'undefined') return
+    // Deleting every rendered row does not empty the feed while further pages are
+    // queued, so suppress the empty-state placeholder until the last page lands.
+    this.element.setAttribute(PAGINATION_PENDING_ATTRIBUTE, 'true')
     this._createSentinel()
   }
 
@@ -266,6 +325,9 @@ export default class extends Controller {
         this._hideLoadMoreIndicator()
         const nodes = Array.isArray(data?.creatives) ? data.creatives : []
         if (nodes.length > 0) {
+          // Belt and braces alongside the pagination-pending guard: a placeholder
+          // that slipped through must never sit above the rows being appended.
+          hideTreeEmptyState(this.element)
           appendCreativeNodes(this.element, nodes)
           dispatchCreativeTreeUpdated(this.element)
           this.queueAlignmentUpdate()
@@ -276,6 +338,10 @@ export default class extends Controller {
           this._repositionSentinel()
         } else {
           this._teardownPagination()
+          // Last page in, and the rows that were on screen when it was requested
+          // may since have been deleted. Nothing is pending any more, so an empty
+          // container now genuinely is an empty feed.
+          restoreTreeEmptyState(this.element)
         }
       })
       .catch((error) => {
@@ -298,6 +364,7 @@ export default class extends Controller {
   }
 
   _teardownPagination() {
+    this.element.removeAttribute(PAGINATION_PENDING_ATTRIBUTE)
     if (this._loadMoreAbort) {
       this._loadMoreAbort.abort()
       this._loadMoreAbort = null
@@ -340,34 +407,76 @@ export default class extends Controller {
   }
 
   showEmptyState() {
-    const html = this.hasEmptyHtmlValue ? this.emptyHtmlValue : ''
-    this.element.innerHTML = html
+    // The placeholder comes from the server-rendered <template> rather than an
+    // HTML string on a data attribute: no innerHTML sink, and the button_to CSRF
+    // token in the "request permission" variant survives.
+    this.element.replaceChildren()
+    restoreTreeEmptyState(this.element)
+    this.markContentLoaded()
+    document.documentElement.classList.add('creative-alignment-ready')
+  }
+
+  // Distinct from showEmptyState(): used when the tree fetch itself fails
+  // (non-2xx, JSON parse failure, or a non-transient network error after
+  // retries are exhausted). The request never actually confirmed the tree is
+  // empty, so this must NOT render the Add/Import creation CTAs — a workspace
+  // that genuinely has creatives would otherwise look empty and invite
+  // duplicate creation.
+  showErrorState() {
+    this.element.replaceChildren()
+    if (this.hasErrorTextValue && this.errorTextValue) {
+      const message = document.createElement('p')
+      message.className = 'creative-tree-error'
+      message.style.textAlign = 'center'
+      message.textContent = this.errorTextValue
+      this.element.appendChild(message)
+    }
     this.markContentLoaded()
     document.documentElement.classList.add('creative-alignment-ready')
   }
 
   showLoadingIndicator() {
     if (!this.loadingIndicator) {
-      const indicator = document.createElement('div')
-      indicator.className = 'creative-tree-loading-placeholder'
-      indicator.setAttribute('role', 'status')
-      indicator.setAttribute('aria-live', 'polite')
-      indicator.setAttribute('aria-label', 'Loading creatives')
-      indicator.innerHTML = `
-        <span class="creative-loading-indicator" aria-hidden="true">
-          <span class="creative-loading-dot">.</span>
-          <span class="creative-loading-dot">.</span>
-          <span class="creative-loading-dot">.</span>
-        </span>
-      `
-      this.loadingIndicator = indicator
+      // The first load's placeholder is already in the DOM: index.html.erb renders
+      // it inside #creatives so the initial paint says "loading" rather than
+      // flashing the empty state until Stimulus boots. Adopt that node instead of
+      // building a replacement — swapping it out would blank the container for a
+      // frame, which is the flicker this whole arrangement exists to avoid.
+      this.loadingIndicator =
+        this.element.querySelector(':scope > [data-creatives-tree-loading]') || this.buildLoadingIndicator()
     }
     this.clearLoadedState()
-    this.element.innerHTML = ''
-    this.element.appendChild(this.loadingIndicator)
+    // replaceChildren over `innerHTML = ''` + appendChild: the adopted placeholder
+    // is a child of the container, so wiping first would detach the very node
+    // being re-inserted.
+    this.element.replaceChildren(this.loadingIndicator)
     this.startAnimation()
   }
 
+  buildLoadingIndicator() {
+    const indicator = document.createElement('div')
+    indicator.className = 'creative-tree-loading-placeholder'
+    indicator.setAttribute('data-creatives-tree-loading', '')
+    indicator.setAttribute('role', 'status')
+    indicator.setAttribute('aria-live', 'polite')
+    indicator.setAttribute('aria-label', this.loadingLabel())
+    indicator.innerHTML = `
+      <span class="creative-loading-indicator" aria-hidden="true">
+        <span class="creative-loading-dot">.</span>
+        <span class="creative-loading-dot">.</span>
+        <span class="creative-loading-dot">.</span>
+      </span>
+    `
+    return indicator
+  }
+
+  loadingLabel() {
+    if (this.hasLoadingTextValue && this.loadingTextValue) return this.loadingTextValue
+    throw new Error(
+      'creatives--tree requires a translated loadingText value when no server loading placeholder is present',
+    )
+  }
+
   hideLoadingIndicator() {
     this.stopAnimation()
     if (this.loadingIndicator && this.loadingIndicator.parentNode === this.element) {

data/app/javascript/controllers/creatives/write_access_request_controller.js

@@ -0,0 +1,58 @@
+import { Controller } from '@hotwired/stimulus'
+import csrfFetch from '../../lib/api/csrf_fetch'
+import { alertDialog } from '../../lib/utils/dialog'
+
+// Powers the "Request write access" CTA in the creative tree's empty state
+// (see engines/collavre/app/views/collavre/creatives/_empty_state.html.erb).
+//
+// There is no backend concept of a "pending request" — Collavre::Concerns::Shareable#request_permission
+// just fires a one-off inbox notification to the owner, it doesn't persist request
+// state anywhere. So the "pending" pill here is a purely client-side, one-time
+// confirmation that the click went through: it swaps in immediately after a
+// successful POST and does NOT survive a page reload (a reload has no way to
+// know a request is outstanding). That's an intentional, honest scope cut —
+// see the PR description for the alternatives considered.
+export default class extends Controller {
+  static targets = ['button', 'pending']
+  static values = { url: String, failureMessage: String }
+
+  async request(event) {
+    event.preventDefault()
+    if (!this.hasUrlValue || !this.hasButtonTarget) return
+
+    this.buttonTarget.disabled = true
+    try {
+      const response = await csrfFetch(this.urlValue, { method: 'POST' })
+      if (response.redirected) {
+        // fetch() follows redirects by default, so an expired session sends
+        // this POST to the sign-in page instead of the permission endpoint —
+        // the final response is a 200 for the login form, not a request
+        // confirmation. Send the browser to the page it actually landed on
+        // rather than claiming the request went through.
+        this.redirectToSignIn(response.url)
+      } else if (response.ok) {
+        this.showPending()
+      } else {
+        this.reportFailure()
+      }
+    } catch {
+      this.reportFailure()
+    }
+  }
+
+  reportFailure() {
+    this.buttonTarget.disabled = false
+    if (this.hasFailureMessageValue) alertDialog(this.failureMessageValue)
+  }
+
+  showPending() {
+    this.buttonTarget.hidden = true
+    if (this.hasPendingTarget) {
+      this.pendingTarget.hidden = false
+    }
+  }
+
+  redirectToSignIn(url) {
+    window.location.href = url
+  }
+}

data/app/javascript/controllers/desktop_proxy_setup_controller.js

@@ -0,0 +1,51 @@
+import { Controller } from "@hotwired/stimulus"
+import csrfFetch from "../lib/api/csrf_fetch"
+
+export function setupNextUrl(nextUrlValue, adapters) {
+  const nextUrl = new URL(nextUrlValue, window.location.origin)
+  for (const adapter of adapters || []) nextUrl.searchParams.set(adapter, "1")
+  return `${nextUrl.pathname}${nextUrl.search}${nextUrl.hash}`
+}
+
+// The browser handles consent and a short-lived registration grant only. The
+// Tauri command keeps proxy secrets in Keychain and posts them directly to the
+// local Rails sidecar, so no secret is exposed to the DOM.
+export default class extends Controller {
+  static targets = ["consent", "submit", "error"]
+  static values = { tokenUrl: String, nextUrl: String, unavailable: String, failed: String }
+
+  toggle() {
+    this.submitTarget.disabled = !this.consentTarget.checked
+  }
+
+  async install() {
+    if (!this.consentTarget.checked) {
+      this.submitTarget.disabled = true
+      return
+    }
+
+    this.errorTarget.hidden = true
+    this.submitTarget.disabled = true
+
+    try {
+      const invoke = window.__TAURI__?.core?.invoke
+      if (!invoke) throw new Error(this.unavailableValue)
+
+      const response = await csrfFetch(this.tokenUrlValue, { method: "POST" })
+      if (!response.ok) throw new Error(this.failedValue)
+      const { token } = await response.json()
+      const result = await invoke("desktop_proxy_complete_setup", {
+        registrationToken: token,
+      })
+      this.navigate(setupNextUrl(this.nextUrlValue, result.adapters))
+    } catch (error) {
+      this.errorTarget.textContent = error?.message || this.failedValue
+      this.errorTarget.hidden = false
+      this.submitTarget.disabled = !this.consentTarget.checked
+    }
+  }
+
+  navigate(url) {
+    window.location.assign(url)
+  }
+}

data/app/javascript/controllers/gateway_check_controller.js

@@ -0,0 +1,36 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["result"]
+  static values = { checking: String, success: String, failed: String }
+
+  async check(event) {
+    const button = event.currentTarget
+    const result = button.parentElement.querySelector("[data-gateway-check-target='result']")
+    button.disabled = true
+    result.textContent = this.checkingValue
+
+    try {
+      const response = await fetch(event.params.url, {
+        method: "POST",
+        headers: { "X-CSRF-Token": this.csrfToken, Accept: "application/json" }
+      })
+      const data = await response.json()
+      if (data.ok && data.identity_verified === false) {
+        result.textContent = `${this.successValue}: ${data.warning || ""}`
+      } else if (data.ok) {
+        result.textContent = `${this.successValue} (${(data.engines || []).join(", ")})`
+      } else {
+        result.textContent = `${this.failedValue}: ${data.error || ""}`
+      }
+    } catch (_error) {
+      result.textContent = this.failedValue
+    } finally {
+      button.disabled = false
+    }
+  }
+
+  get csrfToken() {
+    return document.querySelector("meta[name='csrf-token']")?.content || ""
+  }
+}

data/app/javascript/controllers/index.js

@@ -10,6 +10,7 @@ import CreativesExpansionController from "./creatives/expansion_controller"
 import CreativesRowEditorController from "./creatives/row_editor_controller"
 import CreativesTreeController from "./creatives/tree_controller"
 import CreativesSyncController from "./creatives/sync_controller"
+import CreativesWriteAccessRequestController from "./creatives/write_access_request_controller"
 import CommentsListController from "./comments/list_controller"
 import CommentsFormController from "./comments/form_controller"
 import CommentsPresenceController from "./comments/presence_controller"
@@ -17,6 +18,8 @@ import CommentsMentionMenuController from "./comments/mention_menu_controller"
 import CommentsTopicsController from "./comments/topics_controller"
 import CommentsContextsController from "./comments/contexts_controller"
 import CommentsDropTriggerController from "./comments/drop_trigger_controller"
+import CommentsFeatureCardsController from "./comments/feature_cards_controller"
+import CommentsPlaceholderController from "./comments/placeholder_controller"
 import CommentsPopupController from "./comments/popup_controller"
 import ClickTargetController from "./click_target_controller"
 import TabsController from "./tabs_controller"
@@ -36,6 +39,12 @@ import ImageLightboxController from "./image_lightbox_controller"
 import SearchPopupController from "./search_popup_controller"
 import LandingVideoController from "./landing_video_controller"
 import InboxBadgeController from "./inbox_badge_controller"
+import LastVisitedCreativeController from "./last_visited_creative_controller"
+import WorkspaceTreeController from "./workspace_tree_controller"
+import GatewayCheckController from "./gateway_check_controller"
+import AgentConnectionController from "./agent_connection_controller"
+import AgentVendorController from "./agent_vendor_controller"
+import DesktopProxySetupController from "./desktop_proxy_setup_controller"
 
 // Export all controllers
 export {
@@ -73,7 +82,13 @@ export {
   SearchPopupController,
   CommentBadgeController,
   LandingVideoController,
-  InboxBadgeController
+  InboxBadgeController,
+  LastVisitedCreativeController,
+  WorkspaceTreeController,
+  GatewayCheckController,
+  AgentConnectionController,
+  AgentVendorController,
+  DesktopProxySetupController
 }
 
 // Registration function for use with a Stimulus application
@@ -88,6 +103,7 @@ export function registerControllers(application) {
   application.register("creatives--row-editor", CreativesRowEditorController)
   application.register("creatives--tree", CreativesTreeController)
   application.register("creatives--sync", CreativesSyncController)
+  application.register("creatives--write-access-request", CreativesWriteAccessRequestController)
   application.register("comments--list", CommentsListController)
   application.register("comments--form", CommentsFormController)
   application.register("comments--presence", CommentsPresenceController)
@@ -95,6 +111,8 @@ export function registerControllers(application) {
   application.register("comments--topics", CommentsTopicsController)
   application.register("comments--contexts", CommentsContextsController)
   application.register("comments--drop-trigger", CommentsDropTriggerController)
+  application.register("comments--feature-cards", CommentsFeatureCardsController)
+  application.register("comments--placeholder", CommentsPlaceholderController)
   application.register("comments--popup", CommentsPopupController)
   application.register("click-target", ClickTargetController)
   application.register("tabs", TabsController)
@@ -114,4 +132,10 @@ export function registerControllers(application) {
   application.register("comment-badge", CommentBadgeController)
   application.register("landing-video", LandingVideoController)
   application.register("inbox-badge", InboxBadgeController)
+  application.register("last-visited-creative", LastVisitedCreativeController)
+  application.register("workspace-tree", WorkspaceTreeController)
+  application.register("gateway-check", GatewayCheckController)
+  application.register("agent-connection", AgentConnectionController)
+  application.register("agent-vendor", AgentVendorController)
+  application.register("desktop-proxy-setup", DesktopProxySetupController)
 }