collavre 0.24.0 → 0.25.0

data/app/javascript/controllers/__tests__/agent_connection_controller.test.js

@@ -0,0 +1,195 @@
+/**
+ * @jest-environment jsdom
+ */
+import { Application } from "@hotwired/stimulus"
+
+const { default: AgentConnectionController } = await import("../agent_connection_controller")
+
+describe("AgentConnectionController", () => {
+  let application
+
+  async function mount() {
+    document.body.innerHTML = `
+      <div data-controller="agent-connection"
+           data-agent-connection-status-url-value="/status"
+           data-agent-connection-session-url-value="/auth/__ENGINE__"
+           data-agent-connection-session-detail-url-value="/auth/__ENGINE__/__SESSION__"
+           data-agent-connection-sync-url-value="/sync"
+           data-agent-connection-approve-url-value="/items/__TYPE__/__NAME__/approve"
+           data-agent-connection-delete-url-value="/items/__TYPE__/__NAME__"
+           data-agent-connection-login-value="로그인"
+           data-agent-connection-submit-value="제출"
+           data-agent-connection-base-url-label-value="Provider base URL"
+           data-agent-connection-base-url-help-value="공개 HTTPS 주소를 입력하세요"
+           data-agent-connection-cancel-value="취소"
+           data-agent-connection-open-url-value="인증 페이지 열기"
+           data-agent-connection-approve-value="승인"
+           data-agent-connection-revoke-value="승인 회수"
+           data-agent-connection-error-value="CLI Proxy 오류"
+           data-agent-connection-manifest-unregistered-value="등록된 매니페스트가 없습니다"
+           data-agent-connection-last-error-value="최근 프로비저닝 오류"
+           data-agent-connection-status-labels-value='{"unknown":"알 수 없음","authorized":"인증 완료","not_synced":"동기화되지 않음","pending_approval":"승인 대기","installed":"설치됨"}'
+           data-agent-connection-item-type-labels-value='{"skill":"스킬","config":"설정"}'>
+        <div data-agent-connection-target="error" hidden></div>
+        <div data-agent-connection-target="engines"></div>
+        <div data-agent-connection-target="session"></div>
+        <div data-agent-connection-target="manifest"></div>
+        <table><tbody data-agent-connection-target="provision"></tbody></table>
+      </div>
+    `
+
+    application = Application.start()
+    application.register("agent-connection", AgentConnectionController)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+  }
+
+  beforeEach(() => {
+    global.fetch = async () => ({
+      ok: true,
+      text: async () => JSON.stringify({
+        engines: [{ engine: "claude", status: { state: "unknown" }, flows: [] }],
+        provision: { items: [{ type: "skill", name: "collavre", status: "installed" }] }
+      })
+    })
+  })
+
+  afterEach(() => {
+    application?.stop()
+    application = null
+    document.body.innerHTML = ""
+    delete global.fetch
+  })
+
+  test("renders engine, provisioning, and session states with localized labels", async () => {
+    await mount()
+
+    expect(document.querySelector('[data-agent-connection-target="engines"]').textContent).toContain("알 수 없음")
+    expect(document.querySelector('[data-agent-connection-target="provision"]').textContent).toContain("설치됨")
+    expect(document.querySelector('[data-agent-connection-target="provision"]').textContent).toContain("동기화되지 않음")
+    expect(document.querySelector('[data-agent-connection-target="provision"]').textContent).toContain("스킬")
+    expect(document.querySelector('[data-agent-connection-target="provision"]').textContent).toContain("설정")
+    expect(document.querySelector('[data-agent-connection-target="provision"]').textContent).not.toMatch(/skill|config/)
+
+    const controller = application.getControllerForElementAndIdentifier(
+      document.querySelector('[data-controller="agent-connection"]'),
+      "agent-connection"
+    )
+    controller.renderSession({ engine: "claude", status: "authorized", sessionId: "session-1" })
+
+    expect(document.querySelector('[data-agent-connection-target="session"]').textContent).toContain("claude: 인증 완료")
+  })
+
+  test("falls back to a new proxy status identifier until a translation is added", async () => {
+    await mount()
+    const controller = application.getControllerForElementAndIdentifier(
+      document.querySelector('[data-controller="agent-connection"]'),
+      "agent-connection"
+    )
+
+    expect(controller.statusLabel("future_state")).toBe("future_state")
+    expect(controller.itemTypeLabel("future_type")).toBe("future_type")
+  })
+
+  test("names why provisioning is stalled next to the sync button", async () => {
+    await mount()
+    const controller = application.getControllerForElementAndIdentifier(
+      document.querySelector('[data-controller="agent-connection"]'),
+      "agent-connection"
+    )
+    const manifest = document.querySelector('[data-agent-connection-target="manifest"]')
+
+    expect(manifest.textContent).toContain("등록된 매니페스트가 없습니다")
+
+    controller.renderProvision({ manifest_url: "https://collavre.example/provision.json", last_error: "manifest fetch failed" })
+    expect(manifest.textContent).toContain("최근 프로비저닝 오류: manifest fetch failed")
+
+    controller.renderProvision({ manifest_url: "https://collavre.example/provision.json", items: [] })
+    expect(manifest.textContent).toBe("")
+  })
+
+  test("submits provider credentials under a log-filtered parameter name", async () => {
+    await mount()
+    const controller = application.getControllerForElementAndIdentifier(
+      document.querySelector('[data-controller="agent-connection"]'),
+      "agent-connection"
+    )
+    controller.sessionTarget.innerHTML = '<input data-role="secret" value="provider-secret">'
+    let submitted
+    global.fetch = async (_url, options) => {
+      submitted = JSON.parse(options.body)
+      return { ok: true, text: async () => JSON.stringify({ engine: "codex", status: "pending" }) }
+    }
+
+    await controller.submit({ params: { engine: "codex", session: "session-1" } })
+
+    expect(submitted).toEqual({ auth_secret: "provider-secret" })
+  })
+
+  test("renders and submits base URL only for an advertised custom-provider flow", async () => {
+    await mount()
+    const controller = application.getControllerForElementAndIdentifier(
+      document.querySelector('[data-controller="agent-connection"]'),
+      "agent-connection"
+    )
+    controller.baseUrlFlows = new Map([["codex_custom", ["api-key"]]])
+    controller.renderSession({ engine: "codex_custom", flow: "api-key", status: "pending", sessionId: "session-1" })
+
+    const baseUrl = document.querySelector('[data-role="base-url"]')
+    const secret = document.querySelector('[data-role="secret"]')
+    expect(baseUrl).not.toBeNull()
+    expect(secret).not.toBeNull()
+    expect(document.querySelector('[data-agent-connection-target="session"]').textContent).toContain("Provider base URL")
+    baseUrl.value = "https://openrouter.ai/api/v1"
+    secret.value = "provider-secret"
+
+    let submitted
+    global.fetch = async (_url, options) => {
+      submitted = JSON.parse(options.body)
+      return { ok: true, text: async () => JSON.stringify({ engine: "codex_custom", status: "pending" }) }
+    }
+    await controller.submit({ params: { engine: "codex_custom", session: "session-1" } })
+
+    expect(submitted).toEqual({ auth_secret: "provider-secret", base_url: "https://openrouter.ai/api/v1" })
+
+    controller.baseUrlFlows = new Map()
+    controller.renderSession({ engine: "codex", flow: "api-key", status: "pending", sessionId: "session-2" })
+    expect(document.querySelector('[data-role="base-url"]')).toBeNull()
+  })
+
+  test("does not submit a custom-provider session without a valid base URL", async () => {
+    await mount()
+    const controller = application.getControllerForElementAndIdentifier(
+      document.querySelector('[data-controller="agent-connection"]'),
+      "agent-connection"
+    )
+    controller.baseUrlFlows = new Map([["codex_custom", ["api-key"]]])
+    controller.renderSession({ engine: "codex_custom", flow: "api-key", status: "pending", sessionId: "session-1" })
+
+    const baseUrl = document.querySelector('[data-role="base-url"]')
+    let reportValidityCalls = 0
+    let fetchCalled = false
+    baseUrl.reportValidity = () => {
+      reportValidityCalls += 1
+      return false
+    }
+    global.fetch = async () => { fetchCalled = true }
+
+    await controller.submit({ params: { engine: "codex_custom", session: "session-1" } })
+
+    expect(reportValidityCalls).toBe(1)
+    expect(fetchCalled).toBe(false)
+  })
+
+  test("shows routing detail and remains compatible with proxies without base URL flows", async () => {
+    await mount()
+    const controller = application.getControllerForElementAndIdentifier(
+      document.querySelector('[data-controller="agent-connection"]'),
+      "agent-connection"
+    )
+
+    controller.renderEngines([{ engine: "codex_custom", flow: "api-key", status: { state: "authenticated", detail: "routing to https://openrouter.ai/api/v1" } }])
+
+    expect(document.querySelector('[data-agent-connection-target="engines"]').textContent).toContain("routing to https://openrouter.ai/api/v1")
+    expect(controller.requiresBaseUrl("codex_custom", "api-key")).toBe(false)
+  })
+})

data/app/javascript/controllers/__tests__/desktop_proxy_setup_controller.test.js

@@ -0,0 +1,96 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from "@jest/globals"
+
+const csrfFetch = jest.fn()
+jest.unstable_mockModule("../../lib/api/csrf_fetch", () => ({ default: csrfFetch }))
+
+const { Application } = await import("@hotwired/stimulus")
+const { default: DesktopProxySetupController, setupNextUrl } = await import("../desktop_proxy_setup_controller")
+
+describe("DesktopProxySetupController", () => {
+  let application
+  let controller
+
+  beforeEach(async () => {
+    csrfFetch.mockReset()
+    document.body.innerHTML = `
+      <div data-controller="desktop-proxy-setup"
+           data-desktop-proxy-setup-token-url-value="/desktop/setup/registration_token"
+           data-desktop-proxy-setup-next-url-value="/desktop/setup?step=adapters"
+           data-desktop-proxy-setup-unavailable-value="Desktop support is unavailable"
+           data-desktop-proxy-setup-failed-value="Setup failed">
+        <input type="checkbox" data-desktop-proxy-setup-target="consent">
+      <button disabled data-desktop-proxy-setup-target="submit"></button>
+        <p hidden data-desktop-proxy-setup-target="error"></p>
+      </div>`
+    application = Application.start()
+    application.register("desktop-proxy-setup", DesktopProxySetupController)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    controller = application.getControllerForElementAndIdentifier(
+      document.querySelector("[data-controller='desktop-proxy-setup']"),
+      "desktop-proxy-setup",
+    )
+  })
+
+  afterEach(() => {
+    application.stop()
+    document.body.innerHTML = ""
+    delete window.__TAURI__
+    jest.restoreAllMocks()
+  })
+
+  test("preserves the setup step while appending detected adapters", () => {
+    expect(setupNextUrl("/desktop/setup?step=adapters", [ "claude", "codex" ]))
+      .toBe("/desktop/setup?step=adapters&claude=1&codex=1")
+  })
+
+  test("enables installation only after consent", () => {
+    expect(controller.submitTarget.disabled).toBe(true)
+
+    controller.consentTarget.checked = false
+    controller.toggle()
+    expect(controller.submitTarget.disabled).toBe(true)
+
+    controller.consentTarget.checked = true
+    controller.toggle()
+    expect(controller.submitTarget.disabled).toBe(false)
+  })
+
+  test("does not start installation without consent", async () => {
+    const invoke = jest.fn()
+    window.__TAURI__ = { core: { invoke } }
+
+    await controller.install()
+
+    expect(csrfFetch).not.toHaveBeenCalled()
+    expect(invoke).not.toHaveBeenCalled()
+    expect(controller.submitTarget.disabled).toBe(true)
+  })
+
+  test("registers through Tauri and retains the adapter step", async () => {
+    const invoke = jest.fn().mockResolvedValue({ adapters: [ "claude" ] })
+    window.__TAURI__ = { core: { invoke } }
+    controller.consentTarget.checked = true
+    csrfFetch.mockResolvedValue({ ok: true, json: async () => ({ token: "grant" }) })
+    const navigate = jest.spyOn(controller, "navigate").mockImplementation(() => {})
+
+    await controller.install()
+
+    expect(csrfFetch).toHaveBeenCalledWith("/desktop/setup/registration_token", { method: "POST" })
+    expect(invoke).toHaveBeenCalledWith("desktop_proxy_complete_setup", { registrationToken: "grant" })
+    expect(navigate).toHaveBeenCalledWith("/desktop/setup?step=adapters&claude=1")
+  })
+
+  test("shows a localized failure when native setup is unavailable", async () => {
+    controller.consentTarget.checked = true
+
+    await controller.install()
+
+    expect(controller.errorTarget.hidden).toBe(false)
+    expect(controller.errorTarget.textContent).toBe("Desktop support is unavailable")
+    expect(controller.submitTarget.disabled).toBe(false)
+  })
+})

data/app/javascript/controllers/__tests__/index.test.js

@@ -0,0 +1,42 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { jest } from '@jest/globals'
+import LastVisitedCreativeController from '../last_visited_creative_controller'
+
+describe('registerControllers', () => {
+  test('registers the last-visited Creative controller', async () => {
+    jest.unstable_mockModule('@hotwired/turbo-rails', () => ({ Turbo: {} }))
+    for (const controller of [
+      '../comment_controller',
+      '../comment_version_controller',
+      '../link_creative_controller',
+      '../topic_search_controller',
+      '../topic_list_controller',
+      '../share_modal_controller',
+      '../share_user_search_controller',
+      '../inbox_badge_controller',
+      '../creatives/drag_drop_controller',
+      '../creatives/row_editor_controller',
+      '../creatives/tree_controller',
+      '../creatives/sync_controller',
+      '../comments/list_controller',
+      '../comments/form_controller',
+      '../comments/presence_controller',
+      '../comments/topics_controller',
+      '../comments/popup_controller',
+    ]) {
+      jest.unstable_mockModule(controller, () => ({ default: class {} }))
+    }
+    const { registerControllers } = await import('../index')
+    const application = { register: jest.fn() }
+
+    registerControllers(application)
+
+    expect(application.register).toHaveBeenCalledWith(
+      'last-visited-creative',
+      LastVisitedCreativeController,
+    )
+  })
+})

data/app/javascript/controllers/__tests__/last_visited_creative_controller.test.js

@@ -0,0 +1,103 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { Application } from '@hotwired/stimulus'
+import { jest } from '@jest/globals'
+import LastVisitedCreativeController from '../last_visited_creative_controller'
+
+describe('LastVisitedCreativeController', () => {
+  let application
+  let fetchMock
+
+  beforeEach(async () => {
+    window.localStorage.clear()
+    fetchMock = jest.fn().mockImplementation((url) => Promise.resolve(
+      url === '/creatives/next_last_visited_sequence'
+        ? { ok: true, headers: new Headers(), json: async () => ({ sequence: 2 }) }
+        : { ok: true, headers: new Headers() }
+    ))
+    global.fetch = fetchMock
+    document.head.innerHTML = '<meta name="csrf-token" content="token">'
+    document.body.innerHTML = `
+      <div data-controller="last-visited-creative"
+           data-last-visited-creative-url-value="/creatives"
+           data-last-visited-creative-creative-id-value="2"
+           data-last-visited-creative-visit-token-value="server-token"
+           data-last-visited-creative-visit-sequence-value="1"></div>
+    `
+    application = Application.start()
+    application.register('last-visited-creative', LastVisitedCreativeController)
+    await new Promise((resolve) => requestAnimationFrame(resolve))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+  })
+
+  afterEach(() => {
+    application?.stop()
+    document.head.innerHTML = ''
+    document.body.innerHTML = ''
+    window.localStorage.clear()
+    delete global.fetch
+  })
+
+  test('records a cached history restore', async () => {
+    document.dispatchEvent(new CustomEvent('turbo:visit', { detail: { action: 'restore' } }))
+    document.dispatchEvent(new Event('turbo:render'))
+
+    await new Promise((resolve) => requestAnimationFrame(resolve))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(fetchMock).toHaveBeenCalledWith('/creatives/2/remember_last_visited?visit_token=server-token', expect.objectContaining({
+      method: 'PATCH',
+      credentials: 'same-origin',
+    }))
+    expect(fetchMock.mock.calls[1][1].headers.get('X-Collavre-Last-Visited-Creative-Sequence')).toBe('2')
+  })
+
+  test('records a cached history restore after Turbo reconnects the page', async () => {
+    document.dispatchEvent(new CustomEvent('turbo:visit', { detail: { action: 'restore' } }))
+    document.body.innerHTML = `
+      <div data-controller="last-visited-creative"
+           data-last-visited-creative-url-value="/creatives"
+           data-last-visited-creative-creative-id-value="1"
+           data-last-visited-creative-visit-token-value="server-token"
+           data-last-visited-creative-visit-sequence-value="1"></div>
+    `
+    document.dispatchEvent(new Event('turbo:render'))
+
+    await new Promise((resolve) => requestAnimationFrame(resolve))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(fetchMock).toHaveBeenCalledWith('/creatives/1/remember_last_visited?visit_token=server-token', expect.objectContaining({
+      method: 'PATCH',
+      credentials: 'same-origin',
+    }))
+  })
+
+  test('obtains an ordered visit token from Rails before a Turbo navigation request', async () => {
+    const fetchOptions = { method: 'GET', headers: new Headers() }
+    const resume = jest.fn()
+    const event = new CustomEvent('turbo:before-fetch-request', {
+      cancelable: true,
+      detail: { fetchOptions, resume, url: '/creatives?id=2' },
+    })
+    document.dispatchEvent(event)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(event.defaultPrevented).toBe(true)
+    expect(resume).toHaveBeenCalled()
+    expect(fetchOptions.headers.get('X-Collavre-Last-Visited-Creative-Token')).toBe('server-token')
+    expect(fetchOptions.headers.get('X-Collavre-Last-Visited-Creative-Sequence')).toBe('2')
+  })
+
+  test('uses Rails to allocate a restored visit sequence without browser storage', async () => {
+    document.dispatchEvent(new CustomEvent('turbo:visit', { detail: { action: 'restore' } }))
+    document.dispatchEvent(new Event('turbo:render'))
+    await new Promise((resolve) => requestAnimationFrame(resolve))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(fetchMock).toHaveBeenCalledWith('/creatives/next_last_visited_sequence', expect.objectContaining({ method: 'PATCH' }))
+    expect(fetchMock.mock.calls.at(-1)[1].headers.get('X-Collavre-Last-Visited-Creative-Sequence')).toBe('2')
+  })
+})