Merge branch 'develop' into codex/docker-ci-cache-optimization

.circleci/config.yml

@@ -77,8 +77,7 @@ jobs:
 
       - node/install:
           node-version: '24.13'
-      - node/install-pnpm:
-          version: '10.2.0'
+      - node/install-pnpm
       - node/install-packages:
           pkg-manager: pnpm
           override-ci-command: pnpm i
@@ -119,8 +118,7 @@ jobs:
       - checkout
       - node/install:
           node-version: '24.13'
-      - node/install-pnpm:
-          version: '10.2.0'
+      - node/install-pnpm
       - node/install-packages:
           pkg-manager: pnpm
           override-ci-command: pnpm i
@@ -151,8 +149,7 @@ jobs:
       - checkout
       - node/install:
           node-version: '24.13'
-      - node/install-pnpm:
-          version: '10.2.0'
+      - node/install-pnpm
       - node/install-packages:
           pkg-manager: pnpm
           override-ci-command: pnpm i

.dockerignore

@@ -1,14 +1,21 @@
 .bundle
+.codex
 .env
 .env.*
+.git
+.github
+.agents
 docker-compose.*
 docker/Dockerfile
 docker/dockerfiles
 log
+spec
 storage
+tests
 public/system
 tmp
 .codeclimate.yml
+coverage
 public/packs
 node_modules
 vendor/bundle

.gitea/workflows/build.yaml

@@ -1,24 +0,0 @@
-name: Build Chatwoot
-
-on:
-  push:
-    branches:
-      - leal-cyber
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout source
-        run: |
-          git clone --depth 1 https://github.com/chatwoot/chatwoot.git /source
-          ls /source/docker/Dockerfile
-
-      - name: Build image
-        run: |
-          cd /source
-          docker build -t gitea.lealcyber.com/akadmin/chatwoot:test             -f docker/Dockerfile             --build-arg RAILS_ENV=production             --build-arg BUNDLE_WITHOUT='development:test:enterprise'             --build-arg NODE_OPTIONS='--max-old-space-size=1024' .
-
-      - name: Verify image
-        run: docker images gitea.lealcyber.com/akadmin/chatwoot:test

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+## All enterprise related files should be reviewed by sojan before merging
+/enterprise/* @sojan-official

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+open_collective: chatwoot
+github: chatwoot

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,78 @@
+name: 🐞 Bug report
+description: Create a report to help us improve
+labels: 'Bug'
+body:
+  - type: textarea
+    attributes:
+      label: Describe the bug
+      description: A concise description of what you expected to happen along with screenshots if applicable.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: To Reproduce
+      description: Steps to reproduce the behavior.
+      placeholder: |
+        1. In this environment...
+        2. With this config...
+        3. Run '...'
+        4. See error...
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Expected behavior
+      description: A concise description of what you expected to happen.
+  - type: dropdown
+    id: environment
+    attributes:
+      label: Environment
+      description: Describe whether you are using Chatwoot Cloud (app.chatwoot.com) or a self-hosted installation of Chatwoot. If you are using a self-hosted installation of Chatwoot, describe the type of deployment (Docker/Linux VM installation/Heroku/Kubernetes/Other).
+      options:
+        - app.chatwoot.com
+        - Linux VM
+        - Docker
+        - Kubernetes
+        - Heroku
+        - Other [please specify in the description]
+    validations:
+      required: true
+  - type: dropdown
+    id: provider
+    attributes:
+      label: Cloud Provider
+      description:
+      options:
+        - AWS
+        - GCP
+        - Azure
+        - DigitalOcean
+        - Other [please specify in the description]
+  - type: dropdown
+    id: platform
+    attributes:
+      label: Platform
+      description: Describe the platform you are using
+      options:
+        - Browser
+        - Mobile
+  - type: input
+    attributes:
+      label: Operating system
+      description: The operating system and the version you are using.
+  - type: input
+    attributes:
+      label: Browser and version
+      description: The name of the browser and version you are using.
+  - type: textarea
+    attributes:
+      label: Docker (if applicable)
+      description: |
+        Please share the output of the following. 
+        - `docker version`
+        - `docker info`
+        - `docker-compose version`
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Report a security issue
+    url: https://www.chatwoot.com/docs/contributing-guide/security-reports/
+    about: Guidelines and steps to report a security vulnerability. Please report security vulnerabilities here.
+  - name: Product Documentation
+    url: https://www.chatwoot.com/help-center
+    about: If you have questions, are confused, or just want to understand our product better, please check out our documentation.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,28 @@
+name: 🧙 Feature request
+description: Suggest an idea for this project
+labels: 'feature-request'
+body:
+  - type: textarea
+    attributes:
+      label: Is your feature or enhancement related to a problem? Please describe.
+      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,31 @@
+# Pull Request Template
+
+## Description
+
+Please include a summary of the change and issue(s) fixed. Also, mention relevant motivation, context, and any dependencies that this change requires.
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality not to work as expected)
+- [ ] This change requires a documentation update
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration.
+
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my code
+- [ ] I have commented on my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules

.github/scripts/ghsa_linear_sync.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Sync triage GitHub security advisories to Linear issues."""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any
+
+import requests
+
+GITHUB_API = "https://api.github.com"
+LINEAR_API = "https://api.linear.app/graphql"
+
+SEVERITY_PRIORITY = {"critical": 1, "high": 2, "medium": 3, "low": 4}
+SEVERITY_COLOR = {
+    "critical": 15548997,
+    "high": 15105570,
+    "medium": 15844367,
+    "low": 3066993,
+}
+DEFAULT_COLOR = 9807270
+
+
+def required_env(name: str) -> str:
+    value = os.environ.get(name)
+    if not value:
+        sys.exit(f"Missing required env var: {name}")
+    return value
+
+
+def fetch_triage_advisories(repo: str, token: str) -> list[dict[str, Any]]:
+    url: str | None = f"{GITHUB_API}/repos/{repo}/security-advisories"
+    params: dict[str, Any] | None = {"state": "triage", "per_page": 100}
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "Authorization": f"Bearer {token}",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    advisories: list[dict[str, Any]] = []
+    while url:
+        r = requests.get(url, headers=headers, params=params, timeout=30)
+        r.raise_for_status()
+        advisories.extend(r.json())
+        next_link = r.links.get("next")
+        url = next_link["url"] if next_link else None
+        params = None
+    return advisories
+
+
+def linear_call(query: str, variables: dict[str, Any], api_key: str) -> dict[str, Any]:
+    r = requests.post(
+        LINEAR_API,
+        headers={"Authorization": api_key},
+        json={"query": query, "variables": variables},
+        timeout=30,
+    )
+    r.raise_for_status()
+    return r.json()
+
+
+def linear_issue_exists(ghsa_id: str, api_key: str) -> bool:
+    query = (
+        "query($q: String!) { issues(filter: {title: {contains: $q}}, first: 1) "
+        "{ nodes { id } } }"
+    )
+    resp = linear_call(query, {"q": ghsa_id}, api_key)
+    return len(resp.get("data", {}).get("issues", {}).get("nodes", [])) > 0
+
+
+def linear_create_issue(input_data: dict[str, Any], api_key: str) -> dict[str, str] | None:
+    query = (
+        "mutation($input: IssueCreateInput!) { issueCreate(input: $input) "
+        "{ success issue { identifier url } } }"
+    )
+    resp = linear_call(query, {"input": input_data}, api_key)
+    create = resp.get("data", {}).get("issueCreate") or {}
+    if not create.get("success"):
+        return None
+    return create.get("issue")
+
+
+def reporter_login(advisory: dict[str, Any]) -> str:
+    for credit in advisory.get("credits") or []:
+        user = (credit or {}).get("user") or {}
+        if user.get("login"):
+            return user["login"]
+    return "unknown"
+
+
+def cvss_score(advisory: dict[str, Any]) -> str:
+    score = (advisory.get("cvss") or {}).get("score")
+    return str(score) if score is not None else "n/a"
+
+
+def build_description(adv: dict[str, Any]) -> str:
+    return (
+        f"**GHSA:** {adv['ghsa_id']}\n"
+        f"**CVE:** {adv.get('cve_id') or 'n/a'}\n"
+        f"**Severity:** {adv.get('severity') or 'unknown'} (CVSS {cvss_score(adv)})\n"
+        f"**Reporter:** {reporter_login(adv)}\n"
+        f"**Reported:** {(adv.get('created_at') or '').split('T')[0]}\n"
+        f"**Advisory:** {adv['html_url']}\n\n"
+        f"---\n\n"
+        f"{adv.get('description') or 'No description provided.'}"
+    )
+
+
+def post_discord(adv: dict[str, Any], issue: dict[str, str], webhook_url: str) -> None:
+    severity = adv.get("severity") or "unknown"
+    title = f"[{adv['ghsa_id']}] {adv['summary']}"[:250]
+    payload = {
+        "username": "GHSA Sync",
+        "embeds": [
+            {
+                "title": title,
+                "url": issue["url"],
+                "color": SEVERITY_COLOR.get(severity, DEFAULT_COLOR),
+                "fields": [
+                    {"name": "Linear", "value": issue["identifier"], "inline": True},
+                    {
+                        "name": "Severity",
+                        "value": f"{severity} (CVSS {cvss_score(adv)})",
+                        "inline": True,
+                    },
+                    {
+                        "name": "Advisory",
+                        "value": f"[GitHub]({adv['html_url']})",
+                        "inline": True,
+                    },
+                ],
+            }
+        ],
+    }
+    try:
+        requests.post(webhook_url, json=payload, timeout=10)
+    except requests.RequestException:
+        pass
+
+
+def main() -> int:
+    repo = required_env("GITHUB_REPOSITORY")
+    gh_token = required_env("GHSA_READ_TOKEN")
+    linear_api_key = required_env("LINEAR_API_KEY")
+    team_id = required_env("LINEAR_TEAM_ID")
+    project_id = required_env("LINEAR_PROJECT_ID")
+    label_id = required_env("LINEAR_LABEL_ID")
+    discord_webhook = os.environ.get("DISCORD_WEBHOOK_URL") or None
+
+    advisories = fetch_triage_advisories(repo, gh_token)
+    print(f"Fetched {len(advisories)} triage advisories")
+
+    created = skipped = failed = 0
+
+    for adv in advisories:
+        ghsa_id = adv.get("ghsa_id")
+        if not ghsa_id:
+            failed += 1
+            continue
+
+        try:
+            if linear_issue_exists(ghsa_id, linear_api_key):
+                skipped += 1
+                continue
+
+            severity = adv.get("severity") or "unknown"
+            issue = linear_create_issue(
+                {
+                    "title": f"[{ghsa_id}] {adv.get('summary', '')}",
+                    "description": build_description(adv),
+                    "teamId": team_id,
+                    "projectId": project_id,
+                    "labelIds": [label_id],
+                    "priority": SEVERITY_PRIORITY.get(severity, 3),
+                },
+                linear_api_key,
+            )
+        except requests.RequestException:
+            failed += 1
+            continue
+
+        if not issue:
+            failed += 1
+            continue
+
+        created += 1
+        if discord_webhook:
+            post_discord(adv, issue, discord_webhook)
+
+    print(f"Created {created}, skipped {skipped}, failed {failed}")
+    return 1 if failed > 0 else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/workflows/auto-assign-pr.yml

@@ -0,0 +1,28 @@
+name: Auto-assign PR to Author
+
+on:
+  pull_request:
+    types: [opened]
+
+jobs:
+  auto-assign:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Auto-assign PR to author
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const pull_number = context.payload.pull_request.number;
+            const author = context.payload.pull_request.user.login;
+            
+            await github.rest.issues.addAssignees({
+              owner,
+              repo,
+              issue_number: pull_number,
+              assignees: [author]
+            });
+            
+            console.log(`Assigned PR #${pull_number} to ${author}`);

.github/workflows/deploy_check.yml

@@ -0,0 +1,53 @@
+## github action to check deployment success
+## curl the deployment url and check for 200 status
+## deployment url will be of the form chatwoot-pr-<pr_number>.herokuapp.com
+name: Deploy Check
+
+on:
+  pull_request:
+
+# If two pushes happen within a short time in the same PR, cancel the run of the oldest push
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  deployment_check:
+    name: Check Deployment
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install jq
+        run: sudo apt-get install -y jq
+      - name: Print Deployment URL
+        run: echo "https://chatwoot-pr-${{ github.event.pull_request.number }}.herokuapp.com"
+      - name: Check Deployment Status
+        run: |
+          max_attempts=10
+          attempt=1
+          status_code=0
+          echo "Waiting for review app to be deployed/redeployed, trying in  10 minutes..."
+          sleep 600
+          while [ $attempt -le $max_attempts ]; do
+            response=$(curl -s -o /dev/null -w "%{http_code}" https://chatwoot-pr-${{ github.event.pull_request.number }}.herokuapp.com/api)
+            status_code=$(echo $response | head -n   1)
+            if [ $status_code -eq   200 ]; then
+              body=$(curl -s https://chatwoot-pr-${{ github.event.pull_request.number }}.herokuapp.com/api)
+              if echo "$body" | jq -e '.version and .timestamp and .queue_services == "ok" and .data_services == "ok"' > /dev/null; then
+                echo "Deployment successful"
+                exit 0
+              else
+                echo "Deployment status unknown, retrying in   3 minutes..."
+                sleep 180
+              fi
+            else
+              echo "Waiting for review app to be ready, retrying in  3 minutes..."
+              sleep 180
+              attempt=$((attempt +  1))
+            fi
+          done
+          echo "Deployment failed after $max_attempts attempts"
+          exit  1
+          fi

.github/workflows/frontend-fe.yml

@@ -0,0 +1,44 @@
+name: Frontend Lint & Test
+
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    branches:
+      - develop
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+
+      - name: Install pnpm dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Run eslint
+        run: pnpm run eslint
+
+      - name: Run frontend tests with coverage
+        run: |
+          mkdir -p coverage
+          pnpm run test:coverage

.github/workflows/ghsa-linear-sync.yml

@@ -0,0 +1,29 @@
+name: Sync GHSA advisories to Linear
+
+on:
+  schedule:
+    - cron: '0 4 * * *'  # daily at 09:30 IST
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install dependencies
+        run: pip install requests==2.32.3
+      - name: Sync advisories
+        env:
+          GHSA_READ_TOKEN: ${{ secrets.GHSA_READ_TOKEN }}
+          LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
+          LINEAR_TEAM_ID: ${{ secrets.LINEAR_TEAM_ID }}
+          LINEAR_PROJECT_ID: ${{ secrets.LINEAR_PROJECT_ID }}
+          LINEAR_LABEL_ID: ${{ secrets.LINEAR_LABEL_ID }}
+          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
+        run: python3 .github/scripts/ghsa_linear_sync.py

.github/workflows/lint_pr.yml

@@ -0,0 +1,23 @@
+# ref: https://github.com/amannn/action-semantic-pull-request
+# ensure PR title is in semantic format
+
+name: "Lint PR"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+permissions:
+  pull-requests: read
+
+jobs:
+  main:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v5
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/lock.yml

@@ -0,0 +1,29 @@
+# We often have cases where users would comment over stale closed Github Issues.
+# This creates unnecessary noise for the original reporter and makes it harder for triaging.
+# This action locks the closed threads once it is inactive for over a month.
+
+name: 'Lock Threads'
+
+on:
+  schedule:
+    - cron: '0 * * * *'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: lock
+
+jobs:
+  action:
+    runs-on: ubuntu-latest
+    if: ${{ github.repository == 'chatwoot/chatwoot' }}
+    steps:
+      - uses: dessant/lock-threads@v3
+        with: 
+          issue-inactive-days: '30'
+          issue-lock-reason: 'resolved'
+          pr-inactive-days: '30'
+          pr-lock-reason: 'resolved'

.github/workflows/logging_percentage_check.yml

@@ -0,0 +1,63 @@
+name: Log Lines Percentage Check
+
+on:
+  pull_request:
+    branches:
+      - develop
+
+# If two pushes happen within a short time in the same PR, cancel the run of the oldest push
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  log_lines_check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Check for log lines and calculate percentage
+        run: |
+          # Define the log line pattern
+          LOG_LINE_PATTERN="Rails\.logger"
+
+          # Get the list of changed files in the pull request
+          CHANGED_FILES=$(git diff --name-only)
+
+          # Initialize a flag to track if any files have insufficient log lines
+          INSUFFICIENT_LOGS=0
+
+          for file in $CHANGED_FILES; do
+            if [[ $file =~ \.rb$ && ! $file =~ _spec\.rb$ ]]; then
+              # Count the total number of lines in the file
+              total_lines=$(wc -l < "$file")
+
+              # Count the number of log lines in the file
+              log_lines=$(grep -c "$LOG_LINE_PATTERN" "$file")
+
+              # Calculate the percentage of log lines
+              if [ "$total_lines" -gt 0 ]; then
+                percentage=$(awk "BEGIN { pc=100*${log_lines}/${total_lines}; i=int(pc); print (pc-i<0.5)?i:i+1 }")
+              else
+                percentage=0
+              fi
+
+              # Check if the percentage is less than 5%
+              if [ "$percentage" -lt 5 ]; then
+                echo "Error: Log lines percentage is less than 5% ($percentage%) in $file. Please add more log lines using Rails.logger statements."
+                INSUFFICIENT_LOGS=1
+              else
+                echo "Log lines percentage is $percentage% in $file. Code looks good!"
+              fi
+            fi
+          done
+
+          # If any files have insufficient log lines, fail the action
+          if [ "$INSUFFICIENT_LOGS" -eq 1 ]; then
+            exit 1
+          fi

.github/workflows/nightly_installer.yml

@@ -0,0 +1,55 @@
+# #
+# #
+# # Linux nightly installer action
+# # This action will try to install and setup
+# # chatwoot on an Ubuntu 22.04 machine using
+# # the linux installer script.
+# #
+# # This is set to run daily at midnight.
+# #
+
+name: Run Linux nightly installer
+on:
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  nightly:
+    runs-on: ubuntu-24.04
+    steps:
+
+    - name: get installer
+      run: |
+        wget https://get.chatwoot.app/linux/install.sh
+        chmod +x install.sh
+        #fix for postgtres not starting automatically in gh action env
+        sed -i '/function configure_db() {/a sudo service postgresql start' install.sh
+
+    - name: create input file
+      run: |
+        echo "no" > input
+        echo "yes" >> input
+
+    - name: Run the installer
+      run: |
+        sudo ./install.sh --install < input
+
+        #  disabling http verify for now as http
+        #  access to port 3000 fails in gh action env
+        #    - name: Verify
+        #      if: always()
+        #      run: |
+        #        sudo netstat -ntlp | grep 3000
+        #        sudo systemctl restart chatwoot.target
+        #        curl http://localhost:3000/api
+
+    - name: Upload chatwoot setup log file as an artifact
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: chatwoot-setup-log-file
+        path: /var/log/chatwoot-setup.log

.github/workflows/publish_codespace_image.yml

@@ -0,0 +1,27 @@
+name: Publish Codespace Base Image
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  publish-code-space-image:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Login to GitHub Container Registry
+      uses: docker/login-action@v1
+      with:
+        registry: ghcr.io
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Build the Codespace Base Image
+      run: |
+        docker compose -f .devcontainer/docker-compose.base.yml build base
+        docker push ghcr.io/chatwoot/chatwoot_codespace:latest

.github/workflows/publish_ee_docker.yml

@@ -0,0 +1,149 @@
+# #
+# # This action will publish Chatwoot EE docker image.
+# # This is set to run against merges to develop, master
+# # and when tags are created.
+# #
+
+name: Publish Chatwoot EE docker images
+
+on:
+  push:
+    branches:
+      - develop
+      - master
+    tags:
+      - v*
+  workflow_dispatch:
+
+env:
+  DOCKER_REPO: chatwoot/chatwoot
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+          - platform: linux/arm64
+            runner: ubuntu-22.04-arm
+    runs-on: ${{ matrix.runner }}
+    env:
+      GIT_REF: ${{ github.head_ref || github.ref_name }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Prepare
+        run: |
+          platform=${{ matrix.platform }}
+          echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
+
+      - name: Set Chatwoot edition
+        run: |
+          echo -en '\nENV CW_EDITION="ee"' >> docker/Dockerfile
+
+      - name: Set Docker Tags
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            echo "DOCKER_TAG=${DOCKER_REPO}:latest" >> $GITHUB_ENV
+          else
+            echo "DOCKER_TAG=${DOCKER_REPO}:${SANITIZED_REF}" >> $GITHUB_ENV
+          fi
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: ${{ matrix.platform }}
+          push: ${{ github.event_name == 'push' || github.event_name == 'workflow_dispatch' }}
+          outputs: type=image,name=${{ env.DOCKER_REPO }},push-by-digest=true,name-canonical=true,push=true
+          build-args: |
+            GIT_SHA=${{ github.sha }}
+          cache-from: |
+            type=gha,scope=${{ matrix.platform }}
+            type=gha,scope=${{ matrix.platform }}-ee
+          cache-to: type=gha,mode=max,scope=${{ matrix.platform }}-ee
+
+      - name: Export digest
+        run: |
+          mkdir -p ${{ runner.temp }}/digests
+          digest="${{ steps.build.outputs.digest }}"
+          touch "${{ runner.temp }}/digests/${digest#sha256:}"
+
+      - name: Upload digest
+        uses: actions/upload-artifact@v4
+        with:
+          name: digests-${{ env.PLATFORM_PAIR }}
+          path: ${{ runner.temp }}/digests/*
+          if-no-files-found: error
+          retention-days: 1
+
+  merge:
+    runs-on: ubuntu-latest
+    needs:
+      - build
+    steps:
+      - name: Download digests
+        uses: actions/download-artifact@v4
+        with:
+          path: ${{ runner.temp }}/digests
+          pattern: digests-*
+          merge-multiple: true
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Create manifest list and push
+        working-directory: ${{ runner.temp }}/digests
+        env:
+          GIT_REF: ${{ github.head_ref || github.ref_name }}
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            TAG="${DOCKER_REPO}:latest"
+          else
+            TAG="${DOCKER_REPO}:${SANITIZED_REF}"
+          fi
+
+          docker buildx imagetools create -t $TAG \
+            $(printf '${{ env.DOCKER_REPO }}@sha256:%s ' *)
+
+      - name: Inspect image
+        env:
+          GIT_REF: ${{ github.head_ref || github.ref_name }}
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            TAG="${DOCKER_REPO}:latest"
+          else
+            TAG="${DOCKER_REPO}:${SANITIZED_REF}"
+          fi
+
+          docker buildx imagetools inspect $TAG

.github/workflows/publish_foss_docker.yml

@@ -0,0 +1,154 @@
+# #
+# # This action will publish Chatwoot CE docker image.
+# # This is set to run against merges to develop, master
+# # and when tags are created.
+# #
+
+name: Publish Chatwoot CE docker images
+
+on:
+  push:
+    branches:
+      - develop
+      - master
+    tags:
+      - v*
+  workflow_dispatch:
+
+env:
+  DOCKER_REPO: chatwoot/chatwoot
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+          - platform: linux/arm64
+            runner: ubuntu-22.04-arm
+    runs-on: ${{ matrix.runner }}
+    env:
+      GIT_REF: ${{ github.head_ref || github.ref_name }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Prepare
+        run: |
+          platform=${{ matrix.platform }}
+          echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
+
+      - name: Strip enterprise code
+        run: |
+          rm -rf enterprise
+          rm -rf spec/enterprise
+
+      - name: Set Chatwoot edition
+        run: |
+          echo -en '\nENV CW_EDITION="ce"' >> docker/Dockerfile
+
+      - name: Set Docker Tags
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            echo "DOCKER_TAG=${DOCKER_REPO}:latest-ce" >> $GITHUB_ENV
+          else
+            echo "DOCKER_TAG=${DOCKER_REPO}:${SANITIZED_REF}-ce" >> $GITHUB_ENV
+          fi
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: ${{ matrix.platform }}
+          push: ${{ github.event_name == 'push' || github.event_name == 'workflow_dispatch' }}
+          outputs: type=image,name=${{ env.DOCKER_REPO }},push-by-digest=true,name-canonical=true,push=true
+          build-args: |
+            GIT_SHA=${{ github.sha }}
+          cache-from: |
+            type=gha,scope=${{ matrix.platform }}
+            type=gha,scope=${{ matrix.platform }}-ce
+          cache-to: type=gha,mode=max,scope=${{ matrix.platform }}-ce
+
+      - name: Export digest
+        run: |
+          mkdir -p ${{ runner.temp }}/digests
+          digest="${{ steps.build.outputs.digest }}"
+          touch "${{ runner.temp }}/digests/${digest#sha256:}"
+
+      - name: Upload digest
+        uses: actions/upload-artifact@v4
+        with:
+          name: digests-${{ env.PLATFORM_PAIR }}
+          path: ${{ runner.temp }}/digests/*
+          if-no-files-found: error
+          retention-days: 1
+
+  merge:
+    runs-on: ubuntu-latest
+    needs:
+      - build
+    steps:
+      - name: Download digests
+        uses: actions/download-artifact@v4
+        with:
+          path: ${{ runner.temp }}/digests
+          pattern: digests-*
+          merge-multiple: true
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Create manifest list and push
+        working-directory: ${{ runner.temp }}/digests
+        env:
+          GIT_REF: ${{ github.head_ref || github.ref_name }}
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            TAG="${DOCKER_REPO}:latest-ce"
+          else
+            TAG="${DOCKER_REPO}:${SANITIZED_REF}-ce"
+          fi
+
+          docker buildx imagetools create -t $TAG \
+            $(printf '${{ env.DOCKER_REPO }}@sha256:%s ' *)
+
+      - name: Inspect image
+        env:
+          GIT_REF: ${{ github.head_ref || github.ref_name }}
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            TAG="${DOCKER_REPO}:latest-ce"
+          else
+            TAG="${DOCKER_REPO}:${SANITIZED_REF}-ce"
+          fi
+
+          docker buildx imagetools inspect $TAG

.github/workflows/run_foss_spec.yml

@@ -0,0 +1,146 @@
+name: Run Chatwoot CE spec
+permissions:
+  contents: read
+on:
+  push:
+    branches:
+      - develop
+      - master
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  # Separate linting jobs for faster feedback
+  lint-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      - name: Run Rubocop
+        run: bundle exec rubocop --parallel
+
+  lint-frontend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+      - name: Install pnpm dependencies
+        run: pnpm i
+      - name: Run ESLint
+        run: pnpm run eslint
+
+  # Frontend tests run in parallel with backend
+  frontend-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+      - name: Install pnpm dependencies
+        run: pnpm i
+      - name: Run frontend tests
+        run: pnpm run test:coverage
+
+  # Backend tests with parallelization
+  backend-tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ci_node_total: [16]
+        ci_node_index: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+
+    services:
+      postgres:
+        image: pgvector/pgvector:pg16
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: ''
+          POSTGRES_DB: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: >-
+          --mount type=tmpfs,destination=/var/lib/postgresql/data
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+      redis:
+        image: redis:alpine
+        ports:
+          - 6379:6379
+        options: --entrypoint redis-server
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+
+      - name: Install pnpm dependencies
+        run: pnpm i
+
+      - name: Strip enterprise code
+        run: |
+          rm -rf enterprise
+          rm -rf spec/enterprise
+
+      - name: Create database
+        run: bundle exec rake db:create
+
+      - name: Seed database
+        run: bundle exec rake db:schema:load
+
+      - name: Run backend tests (parallelized)
+        run: |
+          # Get all spec files and split them using round-robin distribution
+          # This ensures slow tests are distributed evenly across all nodes
+          SPEC_FILES=($(find spec -name '*_spec.rb' | sort))
+          TESTS=""
+
+          for i in "${!SPEC_FILES[@]}"; do
+            # Assign spec to this node if: index % total == node_index
+            if [ $(( i % ${{ matrix.ci_node_total }} )) -eq ${{ matrix.ci_node_index }} ]; then
+              TESTS="$TESTS ${SPEC_FILES[$i]}"
+            fi
+          done
+
+          if [ -n "$TESTS" ]; then
+            bundle exec rspec --profile=10 --format progress --format json --out tmp/rspec_results.json $TESTS
+          fi
+        env:
+          NODE_OPTIONS: --openssl-legacy-provider
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: rspec-results-${{ matrix.ci_node_index }}
+          path: tmp/rspec_results.json
+
+      - name: Upload rails log folder
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: rails-log-folder-${{ matrix.ci_node_index }}
+          path: log

.github/workflows/run_mfa_spec.yml

@@ -0,0 +1,100 @@
+name: Run MFA Tests
+permissions:
+  contents: read
+
+on:
+  pull_request:
+
+# If two pushes happen within a short time in the same PR, cancel the run of the oldest push
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+    # Only run if MFA test keys are available
+    if: github.event_name == 'workflow_dispatch' || (github.repository == 'chatwoot/chatwoot' && github.actor != 'dependabot[bot]')
+
+    services:
+      postgres:
+        image: pgvector/pgvector:pg15
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: ''
+          POSTGRES_DB: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: >-
+          --mount type=tmpfs,destination=/var/lib/postgresql/data
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+      redis:
+        image: redis
+        ports:
+          - 6379:6379
+        options: --entrypoint redis-server
+
+    env:
+      RAILS_ENV: test
+      POSTGRES_HOST: localhost
+      # Active Record encryption keys required for MFA - test keys only, not for production use
+      ACTIVE_RECORD_ENCRYPTION_PRIMARY_KEY: 'test_key_a6cde8f7b9c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7'
+      ACTIVE_RECORD_ENCRYPTION_DETERMINISTIC_KEY: 'test_key_b7def9a8c0d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d8'
+      ACTIVE_RECORD_ENCRYPTION_KEY_DERIVATION_SALT: 'test_salt_c8efa0b9d1e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d9'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - name: Create database
+        run: bundle exec rake db:create
+
+      - name: Install pgvector extension
+        run: |
+          PGPASSWORD="" psql -h localhost -U postgres -d chatwoot_test -c "CREATE EXTENSION IF NOT EXISTS vector;"
+
+      - name: Seed database
+        run: bundle exec rake db:schema:load
+
+      - name: Run MFA-related backend tests
+        run: |
+          bundle exec rspec \
+            spec/services/mfa/token_service_spec.rb \
+            spec/services/mfa/authentication_service_spec.rb \
+            spec/requests/api/v1/profile/mfa_controller_spec.rb \
+            spec/controllers/devise_overrides/sessions_controller_spec.rb \
+            spec/models/application_record_external_credentials_encryption_spec.rb \
+            --profile=10 \
+            --format documentation
+        env:
+          NODE_OPTIONS: --openssl-legacy-provider
+
+      - name: Run MFA-related tests in user_spec
+        run: |
+          # Run specific MFA-related tests from user_spec
+          bundle exec rspec spec/models/user_spec.rb \
+            -e "two factor" \
+            -e "2FA" \
+            -e "MFA" \
+            -e "otp" \
+            -e "backup code" \
+            --profile=10 \
+            --format documentation
+        env:
+          NODE_OPTIONS: --openssl-legacy-provider
+
+      - name: Upload test logs
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: mfa-test-logs
+          path: |
+            log/test.log
+            tmp/screenshots/

.github/workflows/size-limit.yml

@@ -0,0 +1,55 @@
+name: Run Size Limit Check
+
+on:
+  pull_request:
+    branches:
+      - develop
+
+# If two pushes happen within a short time in the same PR, cancel the run of the oldest push
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+
+      - name: pnpm
+        run: pnpm install
+
+      - name: Strip enterprise code
+        run: |
+          rm -rf enterprise
+          rm -rf spec/enterprise
+
+      - name: setup env
+        run: |
+          cp .env.example .env
+
+      - name: Run asset compile
+        run: bundle exec rake assets:precompile
+        env:
+          RAILS_ENV: production
+
+      - name: Size Check
+        run: pnpm run size

.github/workflows/stale.yml

@@ -0,0 +1,28 @@
+# This workflow warns and then closes PRs that have had no activity for a specified amount of time.
+#
+# You can adjust the behavior by modifying this file.
+# For more information, see:
+# https://github.com/actions/stale
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: '28 3 * * *'
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+    - uses: actions/stale@v5
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        days-before-issue-close: -1,
+        days-before-issue-stale: -1
+        days-before-pr-close: -1,
+        days-before-pr-stale: 30,
+        stale-pr-message: '🐢 Turtley slow progress alert! This pull request has been idle for over 30 days. Can we please speed things up and either merge it or release it back into the wild?'
+        stale-pr-label: 'stale'

.github/workflows/test_docker_build.yml

@@ -0,0 +1,47 @@
+name: Test Docker Build
+
+on:
+  pull_request:
+    branches:
+      - develop
+      - master
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test-build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+          - platform: linux/arm64
+            runner: ubuntu-22.04-arm
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build Docker image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: ${{ matrix.platform }}
+          push: false
+          load: false
+          build-args: |
+            GIT_SHA=${{ github.sha }}
+          cache-from: |
+            type=gha,scope=${{ matrix.platform }}
+            type=gha,scope=${{ matrix.platform }}-ce
+            type=gha,scope=${{ matrix.platform }}-ee

AGENTS.md

@@ -85,8 +85,8 @@
 ## Project-Specific
 
 - **Translations**:
-  - For product and source-string changes, only update `en.yml` and `en.json`; other languages are handled through Crowdin and the community
-  - Crowdin-generated translation sync PRs may update non-English locale files; do not flag those changes solely for modifying translated locale files
+  - Only update `en.yml` and `en.json`
+  - Other languages are handled by the community
   - Backend i18n → `en.yml`, Frontend i18n → `en.json`
 - **Frontend**:
   - Use `components-next/` for message bubbles (the rest is being deprecated)

Gemfile.lock

@@ -211,14 +211,13 @@ GEM
       activerecord (>= 5.a)
       database_cleaner-core (~> 2.0.0)
     database_cleaner-core (2.0.1)
-    datadog (2.38.0)
-      cgi
-      datadog-ruby_core_source (~> 3.5, >= 3.5.3)
-      libdatadog (~> 36.0.0.1.0)
-      libddwaf (~> 1.30.0.0.0)
+    datadog (2.19.0)
+      datadog-ruby_core_source (~> 3.4, >= 3.4.1)
+      libdatadog (~> 18.1.0.1.0)
+      libddwaf (~> 1.24.1.0.3)
       logger
       msgpack
-    datadog-ruby_core_source (3.5.3)
+    datadog-ruby_core_source (3.4.1)
     date (3.5.1)
     debug (1.8.0)
       irb (>= 1.5.0)
@@ -523,16 +522,15 @@ GEM
       logger (~> 1.6)
     letter_opener (1.10.0)
       launchy (>= 2.2, < 4)
-    libdatadog (36.0.0.1.0)
-    libdatadog (36.0.0.1.0-arm64-darwin)
-    libdatadog (36.0.0.1.0-x86_64-linux)
-    libddwaf (1.30.0.0.2)
+    libdatadog (18.1.0.1.0)
+    libdatadog (18.1.0.1.0-x86_64-linux)
+    libddwaf (1.24.1.0.3)
       ffi (~> 1.0)
-    libddwaf (1.30.0.0.2-arm64-darwin)
+    libddwaf (1.24.1.0.3-arm64-darwin)
       ffi (~> 1.0)
-    libddwaf (1.30.0.0.2-x86_64-darwin)
+    libddwaf (1.24.1.0.3-x86_64-darwin)
       ffi (~> 1.0)
-    libddwaf (1.30.0.0.2-x86_64-linux)
+    libddwaf (1.24.1.0.3-x86_64-linux)
       ffi (~> 1.0)
     line-bot-api (1.28.0)
     lint_roller (1.1.0)
@@ -549,7 +547,7 @@ GEM
       activesupport (>= 4)
       railties (>= 4)
       request_store (~> 1.0)
-    loofah (2.25.2)
+    loofah (2.23.1)
       crass (~> 1.0.2)
       nokogiri (>= 1.12.0)
     mail (2.8.1)
@@ -742,8 +740,8 @@ GEM
       activesupport (>= 5.0.0)
       minitest
       nokogiri (>= 1.6)
-    rails-html-sanitizer (1.7.1)
-      loofah (~> 2.25, >= 2.25.2)
+    rails-html-sanitizer (1.6.1)
+      loofah (~> 2.21)
       nokogiri (>= 1.15.7, != 1.16.7, != 1.16.6, != 1.16.5, != 1.16.4, != 1.16.3, != 1.16.2, != 1.16.1, != 1.16.0.rc1, != 1.16.0)
     rails-i18n (7.0.10)
       i18n (>= 0.7, < 2)
@@ -1032,7 +1030,7 @@ GEM
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
-    websocket-driver (0.8.2)
+    websocket-driver (0.7.7)
       base64
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.5)

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2017-2026 Chatwoot Inc.
+Copyright (c) 2017-2024 Chatwoot Inc.
 
 Portions of this software are licensed as follows:
 

Makefile

@@ -1,6 +1,7 @@
 # Variables
 APP_NAME := chatwoot
 RAILS_ENV ?= development
+GIT_SHA ?= $(shell git rev-parse HEAD 2>/dev/null || echo unknown)
 
 # Targets
 setup:
@@ -61,6 +62,6 @@ debug_worker:
 	overmind connect worker
 
 docker: 
-	docker build -t $(APP_NAME) -f ./docker/Dockerfile .
+	docker build --build-arg GIT_SHA=$(GIT_SHA) -t $(APP_NAME) -f ./docker/Dockerfile .
 
 .PHONY: setup db_create db_migrate db_seed db_reset db console server burn docker run force_run force_run_tunnel debug debug_worker

README.md

@@ -137,9 +137,3 @@ Thanks goes to all these [wonderful people](https://www.chatwoot.com/docs/contri
 
 
 *Chatwoot* © 2017-2026, Chatwoot Inc - Released under the MIT License.
-# Trigger rebuild
-### Runner test
-
-
-
-

VERSION_CW

@@ -1 +1 @@
-4.16.1
+4.15.1

app/builders/agent_builder.rb

@@ -2,14 +2,6 @@
 # It initializes with necessary attributes and provides a perform method
 # to create a user and account user in a transaction.
 class AgentBuilder
-  LIMIT_EXCEEDED_MESSAGE = 'Account limit exceeded. Please purchase more licenses'.freeze
-
-  class LimitExceededError < StandardError
-    def initialize
-      super(AgentBuilder::LIMIT_EXCEEDED_MESSAGE)
-    end
-  end
-
   # Initializes an AgentBuilder with necessary attributes.
   # @param email [String] the email of the user.
   # @param name [String] the name of the user.
@@ -22,23 +14,15 @@ class AgentBuilder
   # Creates a user and account user in a transaction.
   # @return [User] the created user.
   def perform
-    account.with_lock do
-      raise LimitExceededError unless can_add_agent?
-
-      ActiveRecord::Base.transaction do
-        @user = find_or_create_user
-        create_account_user
-      end
+    ActiveRecord::Base.transaction do
+      @user = find_or_create_user
+      create_account_user
     end
     @user
   end
 
   private
 
-  def can_add_agent?
-    account.usage_limits[:agents] > account.account_users.count
-  end
-
   # Finds a user by email or creates a new one with a temporary password.
   # @return [User] the found or created user.
   def find_or_create_user

app/controllers/api/v1/accounts/agent_bots_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::AgentBotsController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action :check_authorization
   before_action :agent_bot, except: [:index, :create]
 

app/controllers/api/v1/accounts/agents_controller.rb

@@ -1,6 +1,8 @@
 class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
   before_action :fetch_agent, except: [:create, :index, :bulk_create]
   before_action :check_authorization
+  before_action :validate_limit, only: [:create]
+  before_action :validate_limit_for_bulk_create, only: [:bulk_create]
 
   def index
     @agents = agents
@@ -18,8 +20,6 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
     )
 
     @agent = builder.perform
-  rescue AgentBuilder::LimitExceededError => e
-    render_payment_required(e.message)
   end
 
   def update
@@ -36,13 +36,25 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
   def bulk_create
     emails = params[:emails]
 
-    bulk_create_agents(emails)
+    emails.each do |email|
+      builder = AgentBuilder.new(
+        email: email,
+        name: email.split('@').first,
+        inviter: current_user,
+        account: Current.account
+      )
+      begin
+        builder.perform
+      rescue ActiveRecord::RecordInvalid => e
+        Rails.logger.info "[Agent#bulk_create] ignoring email #{email}, errors: #{e.record.errors}"
+      end
+    end
+
     # This endpoint is used to bulk create agents during onboarding
     # onboarding_step key in present in Current account custom attributes, since this is a one time operation
-    clear_onboarding_step
+    Current.account.custom_attributes.delete('onboarding_step')
+    Current.account.save!
     head :ok
-  rescue AgentBuilder::LimitExceededError => e
-    render_payment_required(e.message)
   end
 
   private
@@ -75,33 +87,22 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
     @agents ||= Current.account.users.order_by_full_name.includes(:account_users, { avatar_attachment: [:blob] })
   end
 
-  def bulk_create_agents(emails)
-    Current.account.with_lock do
-      raise AgentBuilder::LimitExceededError if emails.count > available_agent_count
+  def validate_limit_for_bulk_create
+    limit_available = params[:emails].count <= available_agent_count
 
-      emails.each { |email| create_agent_from_email(email) }
-    end
+    render_payment_required('Account limit exceeded. Please purchase more licenses') unless limit_available
   end
 
-  def create_agent_from_email(email)
-    builder = AgentBuilder.new(
-      email: email,
-      name: email.split('@').first,
-      inviter: current_user,
-      account: Current.account
-    )
-    builder.perform
-  rescue ActiveRecord::RecordInvalid => e
-    Rails.logger.info "[Agent#bulk_create] ignoring email #{email}, errors: #{e.record.errors}"
-  end
-
-  def clear_onboarding_step
-    Current.account.custom_attributes.delete('onboarding_step')
-    Current.account.save!
+  def validate_limit
+    render_payment_required('Account limit exceeded. Please purchase more licenses') unless can_add_agent?
   end
 
   def available_agent_count
-    Current.account.usage_limits[:agents] - Current.account.account_users.count
+    Current.account.usage_limits[:agents] - agents.count
+  end
+
+  def can_add_agent?
+    available_agent_count.positive?
   end
 
   def delete_user_record(agent)

app/controllers/api/v1/accounts/articles_controller.rb

@@ -30,8 +30,8 @@ class Api::V1::Accounts::ArticlesController < Api::V1::Accounts::BaseController
   end
 
   def update
-    persist_article_changes if params[:article].present?
-    render json: { message: @article.errors.full_messages.to_sentence }, status: :unprocessable_entity and return unless @article.valid?
+    @article.update!(article_params) if params[:article].present?
+    render json: { error: @article.errors.messages }, status: :unprocessable_entity and return unless @article.valid?
   end
 
   def destroy
@@ -67,26 +67,12 @@ class Api::V1::Accounts::ArticlesController < Api::V1::Accounts::BaseController
     @portal ||= Current.account.portals.find_by!(slug: params[:portal_id])
   end
 
-  # Draft-only autosaves must not bump the public-facing updated_at, so write
-  # them with update_columns (which skips the timestamp). update_columns also
-  # skips validations, so assign and validate first to avoid persisting content
-  # that exceeds the column length limit.
-  def persist_article_changes
-    keys = article_params.to_h.keys
-    if keys.any? && (keys - %w[draft_title draft_content]).empty?
-      @article.assign_attributes(article_params)
-      @article.update_columns(article_params.to_h) if @article.valid? # rubocop:disable Rails/SkipsModelValidations
-    else
-      @article.update!(article_params)
-    end
-  end
-
   def article_params
     params.require(:article).permit(
       :title, :slug, :position, :content, :description, :category_id, :author_id, :associated_article_id, :status,
-      :locale, :draft_title, :draft_content, meta: [:title,
-                                                    :description,
-                                                    { tags: [] }]
+      :locale, meta: [:title,
+                      :description,
+                      { tags: [] }]
     )
   end
 

app/controllers/api/v1/accounts/base_controller.rb

@@ -2,14 +2,5 @@ class Api::V1::Accounts::BaseController < Api::BaseController
   include SwitchLocale
   include EnsureCurrentAccountHelper
   before_action :current_account
-  before_action :validate_token_api_access, if: :authenticate_by_access_token?
   around_action :switch_locale_using_account_locale
-
-  private
-
-  def validate_token_api_access
-    return if Current.account.api_and_webhooks_enabled?
-
-    render json: { error: 'API access is not enabled for this account' }, status: :forbidden
-  end
 end

app/controllers/api/v1/accounts/branded_email_layouts_controller.rb

@@ -1,28 +0,0 @@
-class Api::V1::Accounts::BrandedEmailLayoutsController < Api::V1::Accounts::BaseController
-  before_action :check_admin_authorization?
-
-  def show
-    set_branded_email_layout
-  end
-
-  def update
-    unless Current.account.feature_enabled?(:branded_email_templates)
-      render_could_not_create_error('Branded email templates feature is not enabled')
-      return
-    end
-
-    branded_email_layout = params[:branded_email_layout] == 'null' ? nil : params[:branded_email_layout]
-    EmailTemplate.update_account_branded_layout!(account: Current.account, body: branded_email_layout) if params.key?(:branded_email_layout)
-    set_branded_email_layout
-  rescue ActiveRecord::RecordInvalid => e
-    render_could_not_create_error(e.record.errors.full_messages.join(', '))
-  end
-
-  private
-
-  def set_branded_email_layout
-    @branded_email_layout = EmailTemplate.account_branded_layout_template_for(Current.account)&.body
-  end
-end
-
-Api::V1::Accounts::BrandedEmailLayoutsController.prepend_mod_with('Api::V1::Accounts::BrandedEmailLayoutsController')

app/controllers/api/v1/accounts/captain/preferences_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::Captain::PreferencesController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action :authorize_account_update, only: [:update]
 
   def show

app/controllers/api/v1/accounts/conversations/direct_uploads_controller.rb

@@ -1,17 +1,6 @@
 class Api::V1::Accounts::Conversations::DirectUploadsController < ActiveStorage::DirectUploadsController
-  include DeviseTokenAuth::Concerns::SetUserByToken
-  include RequestExceptionHandler
-  include AccessTokenAuthHelper
   include EnsureCurrentAccountHelper
-
-  skip_before_action :verify_authenticity_token, if: :authenticate_by_access_token?
-
-  around_action :handle_with_exception
-  before_action :authenticate_access_token!, if: :authenticate_by_access_token?
-  before_action :validate_bot_access_token!, if: :authenticate_by_access_token?
-  before_action :authenticate_user!, unless: :authenticate_by_access_token?
   before_action :current_account
-  before_action :validate_token_api_access, if: :authenticate_by_access_token?
   before_action :conversation
 
   def create
@@ -22,16 +11,6 @@ class Api::V1::Accounts::Conversations::DirectUploadsController < ActiveStorage:
 
   private
 
-  def authenticate_by_access_token?
-    request.headers[:api_access_token].present? || request.headers[:HTTP_API_ACCESS_TOKEN].present?
-  end
-
-  def validate_token_api_access
-    return if Current.account.api_and_webhooks_enabled?
-
-    render json: { error: 'API access is not enabled for this account' }, status: :forbidden
-  end
-
   def conversation
     @conversation ||= Current.account.conversations.find_by(display_id: params[:conversation_id])
   end

app/controllers/api/v1/accounts/dashboard_apps_controller.rb

@@ -1,5 +1,4 @@
 class Api::V1::Accounts::DashboardAppsController < Api::V1::Accounts::BaseController
-  before_action :check_authorization
   before_action :fetch_dashboard_apps, except: [:create]
   before_action :fetch_dashboard_app, only: [:show, :update, :destroy]
 

app/controllers/api/v1/accounts/data_imports_controller.rb

@@ -1,159 +0,0 @@
-require 'csv'
-
-class Api::V1::Accounts::DataImportsController < Api::V1::Accounts::BaseController
-  DATA_IMPORT_FEATURE = 'data_import'.freeze
-
-  before_action :ensure_data_import_feature_enabled
-  before_action :set_data_import, only: [:show, :start, :abandon, :error_logs, :skip_logs]
-  before_action :check_authorization
-
-  def index
-    @data_imports = policy_scope(Current.account.data_imports).includes(:initiated_by).order(created_at: :desc)
-    data_import_ids = @data_imports.map(&:id)
-    @import_errors_counts = DataImportError.non_skip_logs.where(data_import_id: data_import_ids).group(:data_import_id).count
-    @skip_logs_counts = DataImportError.skip_logs.where(data_import_id: data_import_ids).group(:data_import_id).count
-  end
-
-  def show
-    render_show
-  end
-
-  def validate_source
-    totals = validate_intercom_source
-    render json: { valid: true, totals: totals }
-  rescue DataImports::Intercom::Client::AuthenticationError
-    render_source_validation_error('We could not validate this Intercom access key. Check the key and its permissions.')
-  rescue DataImports::Intercom::Client::Error
-    render_source_validation_error('Intercom could not be reached. Please try again.')
-  rescue ArgumentError => e
-    render_source_validation_error(e.message)
-  end
-
-  def create
-    @data_import = creation_service.perform
-    unless @data_import
-      render json: { message: 'Another data import is already in progress.' }, status: :unprocessable_entity
-      return
-    end
-
-    DataImports::Intercom::ImportJob.perform_later(@data_import, @data_import.active_intercom_import_run_id)
-    render_show
-  rescue DataImports::Intercom::Client::AuthenticationError
-    render_source_validation_error('We could not validate this Intercom access key. Check the key and its permissions.')
-  rescue DataImports::Intercom::Client::Error
-    render_source_validation_error('Intercom could not be reached. Please try again.')
-  rescue ArgumentError => e
-    render_source_validation_error(e.message)
-  end
-
-  def start
-    restart_service = DataImports::Intercom::RestartService.new(account: Current.account, data_import: @data_import)
-    restart_result = restart_service.perform
-    @data_import = restart_service.data_import
-    if restart_result == :access_token_missing
-      render json: { message: 'The Intercom access key for this import is unavailable.' }, status: :unprocessable_entity
-      return
-    end
-
-    DataImports::Intercom::ImportJob.perform_later(@data_import, @data_import.active_intercom_import_run_id) if restart_result == :enqueue
-    render_show
-  end
-
-  def abandon
-    @data_import.abandon!
-    render_show
-  end
-
-  def skip_logs
-    send_data(
-      skip_logs_csv,
-      filename: "data-import-#{@data_import.id}-skip-logs.csv",
-      type: 'text/csv'
-    )
-  end
-
-  def error_logs
-    send_data(
-      error_logs_csv,
-      filename: "data-import-#{@data_import.id}-error-logs.csv",
-      type: 'text/csv'
-    )
-  end
-
-  private
-
-  def ensure_data_import_feature_enabled
-    raise Pundit::NotAuthorizedError unless Current.account.feature_enabled?(DATA_IMPORT_FEATURE)
-  end
-
-  def set_data_import
-    @data_import = Current.account.data_imports.find(params[:id])
-  end
-
-  def check_authorization
-    authorize(@data_import || DataImport)
-  end
-
-  def permitted_params
-    params.permit(:name, :source_provider, :access_token, import_types: [])
-  end
-
-  def creation_service
-    DataImports::Intercom::CreationService.new(
-      account: Current.account,
-      initiated_by: Current.user,
-      source_params: permitted_params.to_h
-    )
-  end
-
-  def import_types
-    return DataImports::Intercom::Importer::DEFAULT_IMPORT_TYPES unless permitted_params.key?(:import_types)
-
-    Array(permitted_params[:import_types]).compact_blank
-  end
-
-  def validate_intercom_source
-    raise ArgumentError, 'Unsupported import source.' unless permitted_params[:source_provider] == 'intercom'
-
-    DataImports::Intercom::CredentialsValidator.new(
-      access_token: permitted_params[:access_token],
-      import_types: import_types
-    ).perform
-  end
-
-  def render_source_validation_error(message)
-    render json: { valid: false, message: message }, status: :unprocessable_entity
-  end
-
-  def render_show
-    @import_errors_finder = DataImportErrorFinder.new(@data_import)
-    @skip_logs_finder = DataImportSkipLogFinder.new(@data_import, params)
-    render :show
-  end
-
-  def skip_logs_csv
-    logs_csv(@data_import.import_errors.skip_logs)
-  end
-
-  def error_logs_csv
-    logs_csv(@data_import.import_errors.non_skip_logs)
-  end
-
-  def logs_csv(logs)
-    CSV.generate(headers: true) do |csv|
-      csv << %w[created_at kind source_object_type source_object_id error_code message details]
-
-      logs.order(:created_at).find_each do |log|
-        csv << [
-          log.created_at.iso8601,
-          log.details['kind'],
-          log.source_object_type,
-          log.source_object_id,
-          log.error_code,
-          log.message,
-          log.details.to_json
-        ]
-      end
-    end
-  end
-end

app/controllers/api/v1/accounts/inboxes_controller.rb

@@ -45,20 +45,11 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
   end
 
   def update
-    continue_update = false
-
-    ActiveRecord::Base.transaction do
-      continue_update = update_branded_email_layout
-      raise ActiveRecord::Rollback unless continue_update
-
-      inbox_params = permitted_params.except(:channel, :csat_config)
-      inbox_params[:csat_config] = format_csat_config(permitted_params[:csat_config]) if permitted_params[:csat_config].present?
-      @inbox.update!(inbox_params)
-      update_inbox_working_hours
-      update_channel if channel_update_required?
-    end
-
-    return unless continue_update
+    inbox_params = permitted_params.except(:channel, :csat_config)
+    inbox_params[:csat_config] = format_csat_config(permitted_params[:csat_config]) if permitted_params[:csat_config].present?
+    @inbox.update!(inbox_params)
+    update_inbox_working_hours
+    update_channel if channel_update_required?
   end
 
   def agent_bot
@@ -133,8 +124,8 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
   end
 
   def reauthorize_and_update_channel(channel_attributes)
-    @inbox.channel.update!(permitted_params(channel_attributes)[:channel])
     @inbox.channel.reauthorized! if @inbox.channel.respond_to?(:reauthorized!)
+    @inbox.channel.update!(permitted_params(channel_attributes)[:channel])
   end
 
   def update_channel_feature_flags
@@ -164,34 +155,6 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
     formatted['template'] = config['template'] if config['template'].present?
   end
 
-  def update_branded_email_layout
-    return true unless params.key?(:branded_email_layout)
-
-    branded_email_layout = normalized_branded_email_layout
-
-    unless Current.account.feature_enabled?(:branded_email_templates)
-      return true if branded_email_layout.blank?
-
-      render_could_not_create_error('Branded email templates feature is not enabled')
-      return false
-    end
-
-    unless @inbox.email?
-      return true if branded_email_layout.blank?
-
-      render_could_not_create_error('Branded email layout is only supported for email inboxes')
-      return false
-    end
-
-    @inbox.update_branded_email_layout!(branded_email_layout)
-    true
-  rescue ActiveRecord::RecordInvalid => e
-    render_could_not_create_error(e.record.errors.full_messages.join(', '))
-    false
-  end
-
-  def normalized_branded_email_layout = params[:branded_email_layout] == 'null' ? nil : params[:branded_email_layout]
-
   def inbox_attributes
     [:name, :avatar, :greeting_enabled, :greeting_message, :enable_email_collect, :csat_survey_enabled,
      :enable_auto_assignment, :working_hours_enabled, :out_of_office_message, :timezone, :allow_messages_after_resolved,

app/controllers/api/v1/accounts/integrations/base_controller.rb

@@ -1,9 +0,0 @@
-class Api::V1::Accounts::Integrations::BaseController < Api::V1::Accounts::BaseController
-  private
-
-  # Managing an integration hook (create/update/destroy) is admin-only, enforced via HookPolicy.
-  # Subclasses opt in per action with `before_action :check_authorization, only: [...]`.
-  def check_authorization
-    authorize(:hook)
-  end
-end

app/controllers/api/v1/accounts/integrations/hooks_controller.rb

@@ -1,4 +1,4 @@
-class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::Integrations::BaseController
+class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::BaseController
   before_action :fetch_hook, except: [:create]
   before_action :check_authorization
 
@@ -35,6 +35,10 @@ class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::Inte
     @hook = Current.account.hooks.find(params[:id])
   end
 
+  def check_authorization
+    authorize(:hook)
+  end
+
   def permitted_params
     params.require(:hook).permit(:app_id, :inbox_id, :status, settings: {})
   end

app/controllers/api/v1/accounts/integrations/linear_controller.rb

@@ -1,7 +1,6 @@
-class Api::V1::Accounts::Integrations::LinearController < Api::V1::Accounts::Integrations::BaseController
+class Api::V1::Accounts::Integrations::LinearController < Api::V1::Accounts::BaseController
   before_action :fetch_conversation, only: [:create_issue, :link_issue, :unlink_issue, :linked_issues]
   before_action :fetch_hook, only: [:destroy]
-  before_action :check_authorization, only: [:destroy]
 
   def destroy
     revoke_linear_token

app/controllers/api/v1/accounts/integrations/notion_controller.rb

@@ -1,6 +1,5 @@
-class Api::V1::Accounts::Integrations::NotionController < Api::V1::Accounts::Integrations::BaseController
+class Api::V1::Accounts::Integrations::NotionController < Api::V1::Accounts::BaseController
   before_action :fetch_hook, only: [:destroy]
-  before_action :check_authorization, only: [:destroy]
 
   def destroy
     @hook.destroy!

app/controllers/api/v1/accounts/integrations/shopify_controller.rb

@@ -1,8 +1,7 @@
-class Api::V1::Accounts::Integrations::ShopifyController < Api::V1::Accounts::Integrations::BaseController
+class Api::V1::Accounts::Integrations::ShopifyController < Api::V1::Accounts::BaseController
   include Shopify::IntegrationHelper
   before_action :setup_shopify_context, only: [:orders]
   before_action :fetch_hook, except: [:auth]
-  before_action :check_authorization, only: [:destroy]
   before_action :validate_contact, only: [:orders]
 
   def auth

app/controllers/api/v1/accounts/labels_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Accounts::LabelsController < Api::V1::Accounts::BaseController
+  before_action :current_account
   before_action :fetch_label, except: [:index, :create]
   before_action :check_authorization
 

app/controllers/api/v1/accounts/microsoft/authorizations_controller.rb

@@ -6,10 +6,7 @@ class Api::V1::Accounts::Microsoft::AuthorizationsController < Api::V1::Accounts
       {
         redirect_uri: "#{base_url}/microsoft/callback",
         scope: scope,
-        state: state,
-        # Force the Microsoft account picker so an already-signed-in account does not
-        # silently authorize and re-bind to an existing inbox in the new-inbox flow.
-        prompt: 'select_account'
+        state: state
       }
     )
     if redirect_url

app/controllers/api/v1/accounts/portals_controller.rb

@@ -81,8 +81,7 @@ class Api::V1::Accounts::PortalsController < Api::V1::Accounts::BaseController
       :name, :page_title, :slug, :archived,
       { config: [:default_locale, :layout, { allowed_locales: [] }, { draft_locales: [] },
                  { social_profiles: %i[facebook x instagram linkedin youtube tiktok github whatsapp] },
-                 { locale_translations: locale_translation_keys.index_with { %i[name page_title header_text] } },
-                 { popular_content: popular_content_keys.index_with { { category_ids: [], article_ids: [] } } }] }
+                 { locale_translations: locale_translation_keys.index_with { %i[name page_title header_text] } }] }
     )
   end
 
@@ -90,10 +89,6 @@ class Api::V1::Accounts::PortalsController < Api::V1::Accounts::BaseController
     params.dig(:portal, :config, :locale_translations)&.keys || []
   end
 
-  def popular_content_keys
-    params.dig(:portal, :config, :popular_content)&.keys || []
-  end
-
   def live_chat_widget_params
     permitted_params = params.permit(:inbox_id)
     return {} unless permitted_params.key?(:inbox_id)

app/controllers/api/v1/accounts/whatsapp/authorizations_controller.rb

@@ -1,7 +1,4 @@
 class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts::BaseController
-  before_action :ensure_embedded_signup_enabled
-  # Reconfiguring/reauthorizing a live inbox swaps its credentials, so restrict it to admins.
-  before_action :check_admin_authorization?, if: -> { params[:inbox_id].present? }
   before_action :fetch_and_validate_inbox, if: -> { params[:inbox_id].present? }
 
   # POST /api/v1/accounts/:account_id/whatsapp/authorization
@@ -19,13 +16,6 @@ class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts:
 
   private
 
-  def ensure_embedded_signup_enabled
-    return unless ChatwootApp.chatwoot_cloud?
-    return if Current.account.feature_enabled?('whatsapp_embedded_signup_inbox_creation')
-
-    raise Pundit::NotAuthorizedError
-  end
-
   def process_embedded_signup
     service = Whatsapp::EmbeddedSignupService.new(
       account: Current.account,
@@ -41,7 +31,7 @@ class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts:
   end
 
   def validate_reauthorization_required
-    return if @inbox.channel.reauthorization_required? || can_reconfigure_channel?
+    return if @inbox.channel.reauthorization_required? || can_upgrade_to_embedded_signup?
 
     render json: {
       success: false,
@@ -49,11 +39,9 @@ class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts:
     }, status: :unprocessable_entity
   end
 
-  def can_reconfigure_channel?
+  def can_upgrade_to_embedded_signup?
     channel = @inbox.channel
     return false unless channel.provider == 'whatsapp_cloud'
-    return true if ChatwootApp.chatwoot_cloud?
-    return Current.account.feature_enabled?('whatsapp_reconfigure') if channel.provider_config['source'] == 'embedded_signup'
 
     true
   end

app/controllers/api/v1/accounts_controller.rb

@@ -8,7 +8,6 @@ class Api::V1::AccountsController < Api::BaseController
   before_action :ensure_account_name, only: [:create]
   before_action :validate_captcha, only: [:create]
   before_action :fetch_account, except: [:create]
-  before_action :validate_token_api_access, if: :authenticate_by_access_token?, except: [:create]
   before_action :check_authorization, except: [:create]
 
   rescue_from CustomExceptions::Account::InvalidEmail,
@@ -106,12 +105,6 @@ class Api::V1::AccountsController < Api::BaseController
     @current_account_user = @account.account_users.find_by(user_id: current_user.id)
   end
 
-  def validate_token_api_access
-    return if @account.api_and_webhooks_enabled?
-
-    render json: { error: 'API access is not enabled for this account' }, status: :forbidden
-  end
-
   def account_params
     params.permit(:account_name, :email, :name, :password, :locale, :domain, :support_email, :user_full_name)
   end

app/controllers/api/v1/widget/base_controller.rb

@@ -59,10 +59,6 @@ class Api::V1::Widget::BaseController < ApplicationController
     permitted_params.dig(:contact, :phone_number)
   end
 
-  def contact_custom_attributes
-    permitted_params.dig(:contact, :custom_attributes)&.to_h
-  end
-
   def browser_params
     {
       browser_name: browser.name,

app/controllers/api/v1/widget/conversations_controller.rb

@@ -19,7 +19,7 @@ class Api::V1::Widget::ConversationsController < Api::V1::Widget::BaseController
   def process_update_contact
     @contact = ContactIdentifyAction.new(
       contact: @contact,
-      params: { email: contact_email, phone_number: contact_phone_number, name: contact_name, custom_attributes: contact_custom_attributes },
+      params: { email: contact_email, phone_number: contact_phone_number, name: contact_name },
       retain_original_contact_name: true,
       discard_invalid_attrs: true
     ).perform
@@ -95,7 +95,7 @@ class Api::V1::Widget::ConversationsController < Api::V1::Widget::BaseController
   end
 
   def permitted_params
-    params.permit(:id, :typing_status, :website_token, :email, contact: [:name, :email, :phone_number, { custom_attributes: {} }],
+    params.permit(:id, :typing_status, :website_token, :email, contact: [:name, :email, :phone_number],
                                                                message: [:content, :referer_url, :timestamp, :echo_id],
                                                                custom_attributes: {})
   end

app/controllers/concerns/ensure_current_account_helper.rb

@@ -14,8 +14,6 @@ module EnsureCurrentAccountHelper
       account_accessible_for_user?(account)
     elsif @resource.is_a?(AgentBot)
       account_accessible_for_bot?(account)
-    else
-      render_unauthorized(I18n.t('errors.account.not_authorized'))
     end
     account
   end
@@ -23,7 +21,7 @@ module EnsureCurrentAccountHelper
   def account_accessible_for_user?(account)
     @current_account_user = account.account_users.find_by(user_id: current_user.id)
     Current.account_user = @current_account_user
-    render_unauthorized(I18n.t('errors.account.not_authorized')) unless @current_account_user
+    render_unauthorized('You are not authorized to access this account') unless @current_account_user
   end
 
   def account_accessible_for_bot?(account)

app/controllers/concerns/portal_home_data.rb

@@ -4,53 +4,17 @@ module PortalHomeData
   private
 
   def load_home_data
-    load_recommended_content
-    # The classic hero only needs the recommendations above; the rest is
-    # documentation-layout home data (also used on custom-domain home pages).
-    return unless @portal.layout == 'documentation'
-
+    base_articles = @portal.articles.published.where(locale: @locale).includes(:author, :category)
     @visible_categories = @portal.categories
                                  .where(locale: @locale)
                                  .joins(:articles).where(articles: { status: :published })
                                  .order(position: :asc)
                                  .group('categories.id')
-    @popular_topics = @recommended_categories.presence || @visible_categories.first(3)
+    @popular_topics = @visible_categories.first(3)
     @featured = base_articles.order_by_views.limit(6)
     @category_contributors = build_category_contributors(@visible_categories)
   end
 
-  def load_recommended_content
-    @recommended_categories = recommended_categories
-    @recommended_articles = recommended_articles
-  end
-
-  def base_articles
-    @base_articles ||= @portal.articles.published.where(locale: @locale).includes(:author, :category)
-  end
-
-  # Admin-recommended categories for the locale, in the chosen order. Unlike the
-  # position-based fallback, published articles aren't required: the admin's pick wins.
-  def recommended_categories
-    ids = @portal.popular_category_ids(@locale)
-    ordered_by_ids(@portal.categories.where(locale: @locale, id: ids), ids)
-  end
-
-  # Admin-recommended articles for the locale, in the chosen order, limited to
-  # published articles that still exist.
-  def recommended_articles
-    ids = @portal.popular_article_ids(@locale)
-    ordered_by_ids(base_articles.where(id: ids), ids)
-  end
-
-  # Loads the scope and returns its records ordered to match `ids`, dropping any
-  # that no longer exist. Skips the query entirely when `ids` is blank.
-  def ordered_by_ids(scope, ids)
-    return [] if ids.blank?
-
-    by_id = scope.index_by(&:id)
-    ids.filter_map { |id| by_id[id] }
-  end
-
   def build_category_contributors(categories)
     category_ids = categories.map(&:id)
     return {} if category_ids.empty?

app/controllers/dashboard_controller.rb

@@ -64,8 +64,10 @@ class DashboardController < ActionController::Base
     return unless @portal
 
     @locale = @portal.default_locale
-    request.variant = :documentation if @portal.layout == 'documentation'
-    load_home_data
+    if @portal.layout == 'documentation'
+      request.variant = :documentation
+      load_home_data
+    end
     render 'public/api/v1/portals/show', layout: 'portal', portal: @portal and return
   end
 

app/controllers/public/api/v1/inboxes/contacts_controller.rb

@@ -18,8 +18,7 @@ class Public::Api::V1::Inboxes::ContactsController < Public::Api::V1::InboxesCon
       contact: @contact_inbox.contact,
       params: permitted_params.to_h.deep_symbolize_keys.except(:identifier)
     )
-    contact_identify_action.perform
-    @contact_inbox.reload
+    render json: contact_identify_action.perform
   end
 
   private

app/controllers/public/api/v1/portals/base_controller.rb

@@ -24,11 +24,7 @@ class Public::Api::V1::Portals::BaseController < PublicController
   end
 
   def set_view_variant
-    request.variant = if @is_plain_layout_enabled
-                        :plain
-                      elsif @portal_layout == 'documentation'
-                        :documentation
-                      end
+    request.variant = :documentation if @portal_layout == 'documentation' && !@is_plain_layout_enabled
   end
 
   def portal
@@ -69,8 +65,6 @@ class Public::Api::V1::Portals::BaseController < PublicController
 
   def render_404
     portal
-    # set_locale can render_404 before the child's set_view_variant runs; set it here so plain 404s stay chrome-less
-    set_view_variant
     render 'public/api/v1/portals/error/404', status: :not_found
   end
 

app/controllers/public/api/v1/portals_controller.rb

@@ -7,7 +7,7 @@ class Public::Api::V1::PortalsController < Public::Api::V1::Portals::BaseControl
   before_action :set_portal_layout
   before_action :set_view_variant
   before_action :ensure_portal_feature_enabled
-  before_action :load_home_data, only: [:show], unless: -> { @is_plain_layout_enabled }
+  before_action :load_home_data, only: [:show], if: -> { @portal_layout == 'documentation' }
   layout 'portal'
 
   def show

app/controllers/webhooks/whatsapp_controller.rb

@@ -47,10 +47,18 @@ class Webhooks::WhatsappController < ActionController::API
     metadata = params.dig(:entry, 0, :changes, 0, :value, :metadata)
     return if metadata.blank?
 
-    Whatsapp::WebhookChannelFinderService.new(
-      display_phone_number: metadata[:display_phone_number],
-      phone_number_id: metadata[:phone_number_id]
-    ).perform
+    phone_number = normalized_phone_number(metadata[:display_phone_number])
+    phone_number_id = metadata[:phone_number_id]
+    channel = Channel::Whatsapp.find_by(phone_number: phone_number)
+
+    return channel if channel && channel.provider_config['phone_number_id'] == phone_number_id
+  end
+
+  def normalized_phone_number(phone_number)
+    return if phone_number.blank?
+
+    phone_number = phone_number.to_s
+    phone_number.start_with?('+') ? phone_number : "+#{phone_number}"
   end
 
   def inactive_whatsapp_number?

app/drops/conversation_drop.rb

@@ -1,10 +1,6 @@
 class ConversationDrop < BaseDrop
   include MessageFormatHelper
 
-  def id
-    @obj.try(:display_id)
-  end
-
   def display_id
     @obj.try(:display_id)
   end

app/drops/inbox_drop.rb

@@ -2,18 +2,4 @@ class InboxDrop < BaseDrop
   def name
     @obj.try(:name)
   end
-
-  def business_name
-    @obj.try(:sanitized_business_name)
-  end
-
-  def avatar_url
-    @obj.try(:avatar_url)
-  end
-
-  def email
-    return unless @obj.try(:email?)
-
-    @obj.try(:email_address).presence || @obj.try(:channel).try(:email)
-  end
 end

app/finders/data_import_error_finder.rb

@@ -1,11 +0,0 @@
-class DataImportErrorFinder
-  RESULTS_LIMIT = 5
-
-  def initialize(data_import)
-    @data_import = data_import
-  end
-
-  def import_errors
-    @data_import.import_errors.non_skip_logs.order(created_at: :desc).limit(RESULTS_LIMIT)
-  end
-end

app/finders/data_import_skip_log_finder.rb

@@ -1,35 +0,0 @@
-class DataImportSkipLogFinder
-  RESULTS_LIMIT = 5
-  SOURCE_OBJECT_TYPES = %w[contact conversation message].freeze
-
-  attr_reader :selected_source_object_type
-
-  def initialize(data_import, params = {})
-    @data_import = data_import
-    @selected_source_object_type = valid_source_object_type(params[:skip_logs_type])
-  end
-
-  def skip_logs
-    filtered_scope.order(created_at: :desc).limit(RESULTS_LIMIT)
-  end
-
-  def counts_by_type
-    base_scope.group(:source_object_type).count
-  end
-
-  private
-
-  def base_scope
-    @base_scope ||= @data_import.import_errors.skip_logs
-  end
-
-  def filtered_scope
-    return base_scope if selected_source_object_type.blank?
-
-    base_scope.where(source_object_type: selected_source_object_type)
-  end
-
-  def valid_source_object_type(source_object_type)
-    source_object_type if SOURCE_OBJECT_TYPES.include?(source_object_type)
-  end
-end

app/javascript/dashboard/api/calls.js

@@ -1,14 +0,0 @@
-/* global axios */
-import ApiClient from './ApiClient';
-
-class CallsAPI extends ApiClient {
-  constructor() {
-    super('calls', { accountScoped: true });
-  }
-
-  get(params = {}) {
-    return axios.get(this.url, { params });
-  }
-}
-
-export default new CallsAPI();

app/javascript/dashboard/api/captain/agentSessions.js

@@ -1,9 +0,0 @@
-import ApiClient from '../ApiClient';
-
-class CaptainAgentSessions extends ApiClient {
-  constructor() {
-    super('captain/agent_sessions', { accountScoped: true });
-  }
-}
-
-export default new CaptainAgentSessions();

app/javascript/dashboard/api/captain/assistant.js

@@ -26,40 +26,16 @@ class CaptainAssistant extends ApiClient {
     });
   }
 
-  getMetrics({ assistantId, range, signal }) {
-    const requestConfig = {
+  getStats({ assistantId, range }) {
+    return axios.get(`${this.url}/${assistantId}/stats`, {
       params: { range, timezone_offset: getTimezoneOffset() },
-    };
-    if (signal) requestConfig.signal = signal;
-
-    return axios.get(`${this.url}/${assistantId}/metrics`, requestConfig);
-  }
-
-  getFaqStats({ assistantId, signal }) {
-    const requestConfig = {};
-    if (signal) requestConfig.signal = signal;
-
-    return axios.get(`${this.url}/${assistantId}/faq_stats`, requestConfig);
-  }
-
-  getSummary({ assistantId, range, stats }) {
-    return axios.get(`${this.url}/${assistantId}/summary`, {
-      params: { range, timezone_offset: getTimezoneOffset(), stats },
     });
   }
 
-  getDrilldown({ assistantId, metric, range, page, signal }) {
-    const requestConfig = {
-      params: {
-        metric,
-        range,
-        timezone_offset: getTimezoneOffset(),
-        page,
-      },
-    };
-    if (signal) requestConfig.signal = signal;
-
-    return axios.get(`${this.url}/${assistantId}/drilldown`, requestConfig);
+  getSummary({ assistantId, range }) {
+    return axios.get(`${this.url}/${assistantId}/summary`, {
+      params: { range, timezone_offset: getTimezoneOffset() },
+    });
   }
 }
 

app/javascript/dashboard/api/channel/whatsapp/whatsappCallsAPI.js

@@ -10,13 +10,10 @@ class WhatsappCallsAPI extends ApiClient {
     return axios.get(`${this.url}/${callId}`).then(r => r.data);
   }
 
-  // Either conversationId, or contactId + inboxId to let the BE resolve the conversation.
-  initiate({ conversationId, contactId, inboxId }, sdpOffer) {
+  initiate(conversationId, sdpOffer) {
     return axios
       .post(`${this.url}/initiate`, {
         conversation_id: conversationId,
-        contact_id: contactId,
-        inbox_id: inboxId,
         sdp_offer: sdpOffer,
       })
       .then(r => r.data);

app/javascript/dashboard/api/dataImports.js

@@ -1,39 +0,0 @@
-/* global axios */
-
-import ApiClient from './ApiClient';
-
-class DataImportsAPI extends ApiClient {
-  constructor() {
-    super('data_imports', { accountScoped: true });
-  }
-
-  start(id) {
-    return axios.post(`${this.url}/${id}/start`);
-  }
-
-  abandon(id) {
-    return axios.post(`${this.url}/${id}/abandon`);
-  }
-
-  show(id, params = {}) {
-    return axios.get(`${this.url}/${id}`, { params });
-  }
-
-  validateSource(payload) {
-    return axios.post(`${this.url}/validate_source`, payload);
-  }
-
-  downloadSkipLogs(id) {
-    return axios.get(`${this.url}/${id}/skip_logs.csv`, {
-      responseType: 'blob',
-    });
-  }
-
-  downloadErrorLogs(id) {
-    return axios.get(`${this.url}/${id}/error_logs.csv`, {
-      responseType: 'blob',
-    });
-  }
-}
-
-export default new DataImportsAPI();

app/javascript/dashboard/api/helpCenter/articles.js

@@ -17,7 +17,6 @@ class ArticlesAPI extends PortalsAPI {
     categorySlug,
     sort,
     query,
-    signal,
   }) {
     const url = getArticleSearchURL({
       pageNumber,
@@ -31,7 +30,7 @@ class ArticlesAPI extends PortalsAPI {
       host: this.url,
     });
 
-    return axios.get(url, { signal });
+    return axios.get(url);
   }
 
   searchArticles({ portalSlug, query }) {

app/javascript/dashboard/api/specs/article.spec.js

@@ -37,8 +37,7 @@ describe('#PortalAPI', () => {
         authorId: '1',
       });
       expect(axiosMock.get).toHaveBeenCalledWith(
-        '/api/v1/portals/room-rental/articles?page=1&locale=en-US&status=published&author_id=1',
-        { signal: undefined }
+        '/api/v1/portals/room-rental/articles?page=1&locale=en-US&status=published&author_id=1'
       );
     });
   });

app/javascript/dashboard/components-next/AssignmentPolicy/AssignmentPolicyCard/AssignmentPolicyCard.vue

@@ -28,12 +28,7 @@ const inboxes = computed(() => {
     return {
       name: inbox.name,
       id: inbox.id,
-      icon: getInboxIconByType(
-        inbox.channelType,
-        inbox.medium,
-        'line',
-        inbox.voiceEnabled
-      ),
+      icon: getInboxIconByType(inbox.channelType, inbox.medium, 'line'),
     };
   });
 });

app/javascript/dashboard/components-next/Calls/CallListItem.vue

@@ -1,244 +0,0 @@
-<script setup>
-import { computed } from 'vue';
-import { useRoute } from 'vue-router';
-import { useI18n } from 'vue-i18n';
-import { relativeDayTimestamp } from 'shared/helpers/timeHelper';
-import { getInboxVoiceIcon } from 'dashboard/helper/inbox';
-import Avatar from 'dashboard/components-next/avatar/Avatar.vue';
-import Icon from 'dashboard/components-next/icon/Icon.vue';
-import AudioPlayer from 'dashboard/components-next/audio/AudioPlayer.vue';
-import {
-  VOICE_CALL_DIRECTION,
-  VOICE_CALL_STATUS,
-} from 'dashboard/components-next/message/constants';
-import CallStatusBadge from './CallStatusBadge.vue';
-import { CALL_KIND, getCallKind } from './constants';
-
-const props = defineProps({
-  call: {
-    type: Object,
-    required: true,
-  },
-});
-
-const { t } = useI18n();
-const route = useRoute();
-
-const kind = computed(() => getCallKind(props.call));
-
-const contactName = computed(() =>
-  (props.call.contact.name || props.call.contact.phoneNumber || '').replace(
-    /^\+/,
-    ''
-  )
-);
-
-const agentActionLabel = computed(() => {
-  if (!props.call.agent) return '';
-  if (kind.value === CALL_KIND.OUTGOING) return t('CALLS_PAGE.ROW.DIALED_BY');
-  if (kind.value === CALL_KIND.INCOMING) return t('CALLS_PAGE.ROW.PICKED_BY');
-  // Ongoing collapses direction, so resolve dialed-vs-picked from the raw value.
-  if (kind.value === CALL_KIND.ONGOING) {
-    return props.call.direction === VOICE_CALL_DIRECTION.OUTBOUND
-      ? t('CALLS_PAGE.ROW.DIALED_BY')
-      : t('CALLS_PAGE.ROW.PICKED_BY');
-  }
-  return '';
-});
-
-const resultLabel = computed(() => {
-  if (kind.value === CALL_KIND.MISSED) return t('CALLS_PAGE.ROW.NO_AGENT');
-  if (kind.value === CALL_KIND.NO_REPLY) {
-    return t('CALLS_PAGE.ROW.NO_CONTACT_ANSWER');
-  }
-  if (kind.value === CALL_KIND.FAILED) return t('CALLS_PAGE.ROW.FAILED');
-  if (kind.value === CALL_KIND.ONGOING) {
-    return props.call.status === VOICE_CALL_STATUS.RINGING
-      ? t('CALLS_PAGE.ROW.RINGING')
-      : t('CALLS_PAGE.ROW.IN_PROGRESS');
-  }
-  return t('CALLS_PAGE.ROW.ANSWERED');
-});
-
-const providerIcon = computed(() =>
-  getInboxVoiceIcon(props.call.inbox.channelType, props.call.inbox.medium)
-);
-
-const createdAtLabel = computed(() =>
-  relativeDayTimestamp(props.call.createdAt, t('CALLS_PAGE.ROW.YESTERDAY'))
-);
-
-const conversationRoute = computed(() => ({
-  name: 'inbox_conversation',
-  params: {
-    accountId: route.params.accountId,
-    conversation_id: props.call.conversation.displayId,
-  },
-  query: { messageId: props.call.messageId },
-}));
-</script>
-
-<template>
-  <div class="flex flex-col gap-2 py-3.5 border-b border-n-weak lg:hidden">
-    <div class="flex items-center gap-2 min-w-0">
-      <Avatar
-        :src="call.contact.avatar"
-        :name="contactName"
-        :size="24"
-        rounded-full
-      />
-      <span
-        v-tooltip.top="{ content: contactName, delay: { show: 500, hide: 0 } }"
-        class="text-heading-3 font-medium truncate text-n-slate-12 min-w-0"
-      >
-        {{ contactName }}
-      </span>
-      <CallStatusBadge :kind="kind" class="ms-auto shrink-0" />
-      <RouterLink
-        :to="conversationRoute"
-        class="inline-flex items-center h-6 gap-1 px-2 text-label-small outline outline-1 -outline-offset-1 rounded-md outline-n-weak text-n-slate-11 hover:bg-n-alpha-1 shrink-0"
-      >
-        <Icon icon="i-lucide-message-circle" class="size-3.5 text-n-slate-11" />
-        {{ call.conversation.displayId }}
-        <Icon icon="i-lucide-arrow-up-right" class="size-3.5 text-n-slate-11" />
-      </RouterLink>
-    </div>
-    <div class="flex items-center gap-1.5 min-w-0">
-      <template v-if="agentActionLabel">
-        <span class="text-label-small text-n-slate-10 shrink-0">
-          {{ agentActionLabel }}
-        </span>
-        <Avatar
-          :src="call.agent.avatar"
-          :name="call.agent.name"
-          :size="20"
-          rounded-full
-        />
-        <span class="text-body-main truncate text-n-slate-12 min-w-0">
-          {{ call.agent.name }}
-        </span>
-      </template>
-      <span v-else class="text-body-main truncate text-n-slate-10 min-w-0">
-        {{ resultLabel }}
-      </span>
-      <span class="w-px h-3 bg-n-strong shrink-0" />
-      <Icon :icon="providerIcon" class="size-4 text-n-slate-11 shrink-0" />
-      <span class="text-body-main truncate text-n-slate-11 min-w-0">
-        {{ call.inbox.name }}
-      </span>
-      <span
-        v-if="!call.recordingUrl"
-        class="ms-auto shrink-0 text-label-small text-n-slate-11 tabular-nums"
-      >
-        {{ createdAtLabel }}
-      </span>
-    </div>
-    <div
-      v-if="call.recordingUrl"
-      class="flex items-center gap-2 min-w-0 justify-between"
-    >
-      <AudioPlayer
-        :src="call.recordingUrl"
-        :fallback-duration="call.durationSeconds || 0"
-        class="flex-1 sm:flex-[0.7] min-w-0"
-      />
-      <span class="shrink-0 text-label-small text-n-slate-11 tabular-nums">
-        {{ createdAtLabel }}
-      </span>
-    </div>
-  </div>
-
-  <div
-    class="hidden items-center gap-x-1.5 gap-y-2.5 border-b border-n-weak lg:flex lg:items-center lg:gap-1.5"
-  >
-    <div class="flex items-center gap-2.5 min-w-0 w-52 shrink-0 py-3.5">
-      <Avatar
-        :src="call.contact.avatar"
-        :name="contactName"
-        :size="24"
-        rounded-full
-      />
-      <span
-        v-tooltip.top="{ content: contactName, delay: { show: 500, hide: 0 } }"
-        class="text-heading-3 font-medium truncate text-n-slate-12"
-      >
-        {{ contactName }}
-      </span>
-    </div>
-    <div
-      class="flex flex-nowrap items-center gap-x-2 gap-y-2 min-w-0 grow shrink"
-    >
-      <div class="flex items-center gap-x-2 min-w-0 lg:contents py-3.5">
-        <CallStatusBadge :kind="kind" class="shrink-0" />
-        <div
-          v-if="agentActionLabel"
-          class="gap-x-1.5 min-w-0 flex items-center"
-        >
-          <span
-            class="text-label-small text-n-slate-10 truncate shrink min-w-8 xl:min-w-14"
-          >
-            {{ agentActionLabel }}
-          </span>
-          <span class="flex items-center gap-1.5 min-w-16 shrink-[20]">
-            <Avatar
-              :src="call.agent.avatar"
-              :name="call.agent.name"
-              :size="20"
-              rounded-full
-            />
-            <span
-              v-tooltip.top="{
-                content: call.agent.name,
-                delay: { show: 500, hide: 0 },
-              }"
-              class="text-body-main truncate text-n-slate-12 min-w-0"
-            >
-              {{ call.agent.name }}
-            </span>
-          </span>
-        </div>
-        <span
-          v-else-if="resultLabel"
-          class="text-body-main truncate text-n-slate-10 min-w-0 shrink-[20]"
-        >
-          {{ resultLabel }}
-        </span>
-      </div>
-      <AudioPlayer
-        v-if="call.recordingUrl"
-        :src="call.recordingUrl"
-        :fallback-duration="call.durationSeconds || 0"
-        class="w-auto min-w-44 shrink mx-auto"
-      />
-    </div>
-    <div
-      v-tooltip.top="{
-        content: call.inbox.name,
-        delay: { show: 500, hide: 0 },
-      }"
-      class="flex items-center gap-1 justify-end w-40 min-w-4 shrink-[100] py-3.5"
-    >
-      <Icon :icon="providerIcon" class="size-4 text-n-slate-11 shrink-0" />
-      <span class="text-body-main truncate text-n-slate-11 min-w-0">
-        {{ call.inbox.name }}
-      </span>
-    </div>
-    <RouterLink
-      :to="conversationRoute"
-      class="inline-flex items-center h-6 gap-1 px-2 text-label-small py-3.5 outline outline-1 -outline-offset-1 rounded-md outline-n-weak text-n-slate-11 hover:bg-n-alpha-1 shrink-0 justify-self-start"
-    >
-      <Icon icon="i-lucide-message-circle" class="size-3.5 text-n-slate-11" />
-      {{ call.conversation.displayId }}
-      <Icon icon="i-lucide-arrow-up-right" class="size-3.5 text-n-slate-11" />
-    </RouterLink>
-    <span
-      v-tooltip.top="{
-        content: createdAtLabel,
-        delay: { show: 500, hide: 0 },
-      }"
-      class="text-label-small text-end text-n-slate-11 truncate py-3.5 tabular-nums justify-self-end min-w-16 max-w-20 shrink-0"
-    >
-      {{ createdAtLabel }}
-    </span>
-  </div>
-</template>

app/javascript/dashboard/components-next/Calls/CallRecordingPlayer.vue

@@ -1,158 +0,0 @@
-<script setup>
-import { computed, getCurrentInstance, ref, useTemplateRef } from 'vue';
-import { downloadFile } from '@chatwoot/utils';
-import { useEmitter } from 'dashboard/composables/emitter';
-import { emitter } from 'shared/helpers/mitt';
-import Button from 'dashboard/components-next/button/Button.vue';
-import Icon from 'dashboard/components-next/icon/Icon.vue';
-
-const props = defineProps({
-  src: {
-    type: String,
-    required: true,
-  },
-  fallbackDuration: {
-    type: Number,
-    default: 0,
-  },
-});
-
-const PLAYBACK_SPEEDS = [1, 1.5, 2];
-
-const audioPlayer = useTemplateRef('audioPlayer');
-const { uid } = getCurrentInstance();
-
-const isPlaying = ref(false);
-const currentTime = ref(0);
-const duration = ref(props.fallbackDuration);
-const playbackSpeed = ref(1);
-
-const onLoadedMetadata = () => {
-  const loadedDuration = audioPlayer.value?.duration;
-  if (Number.isFinite(loadedDuration)) duration.value = loadedDuration;
-};
-
-const formatTime = time => {
-  if (!time || Number.isNaN(time)) return '00:00';
-  const minutes = Math.floor(time / 60);
-  const seconds = Math.floor(time % 60);
-  return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
-};
-
-const playbackSpeedLabel = computed(() => `${playbackSpeed.value}x`);
-
-const displayedTime = computed(() =>
-  formatTime(
-    isPlaying.value || currentTime.value ? currentTime.value : duration.value
-  )
-);
-
-// Only one recording should play at a time across the list.
-useEmitter('pause_playing_audio', currentPlayingId => {
-  if (currentPlayingId !== uid && isPlaying.value) {
-    audioPlayer.value?.pause();
-    isPlaying.value = false;
-  }
-});
-
-const playOrPause = () => {
-  if (isPlaying.value) {
-    audioPlayer.value.pause();
-    isPlaying.value = false;
-  } else {
-    emitter.emit('pause_playing_audio', uid);
-    audioPlayer.value.play();
-    isPlaying.value = true;
-  }
-};
-
-const onTimeUpdate = () => {
-  currentTime.value = audioPlayer.value?.currentTime;
-};
-
-const seek = event => {
-  const time = Number(event.target.value);
-  audioPlayer.value.currentTime = time;
-  currentTime.value = time;
-};
-
-const onEnd = () => {
-  isPlaying.value = false;
-  currentTime.value = 0;
-};
-
-const changePlaybackSpeed = () => {
-  const currentIndex = PLAYBACK_SPEEDS.indexOf(playbackSpeed.value);
-  playbackSpeed.value =
-    PLAYBACK_SPEEDS[(currentIndex + 1) % PLAYBACK_SPEEDS.length];
-  audioPlayer.value.playbackRate = playbackSpeed.value;
-};
-
-const downloadRecording = () => {
-  downloadFile({ url: props.src, type: 'audio' });
-};
-</script>
-
-<template>
-  <div
-    class="flex items-center justify-center h-9 gap-2 px-2 rounded-full bg-n-alpha-1 dark:bg-n-alpha-2 overflow-hidden"
-    @click.stop
-  >
-    <audio
-      ref="audioPlayer"
-      class="hidden"
-      playsinline
-      @loadedmetadata="onLoadedMetadata"
-      @timeupdate="onTimeUpdate"
-      @ended="onEnd"
-    >
-      <source :src="src" />
-    </audio>
-    <Button
-      variant="ghost"
-      color="slate"
-      size="xs"
-      class="!w-6 !p-0 text-n-slate-12"
-      @click="playOrPause"
-    >
-      <template #icon>
-        <Icon
-          :icon="isPlaying ? 'i-lucide-pause' : 'i-lucide-play'"
-          class="size-4 flex-shrink-0"
-        />
-      </template>
-    </Button>
-    <input
-      type="range"
-      min="0"
-      :max="duration || 0"
-      :value="currentTime"
-      class="flex-1 min-w-0 lg:grow-0 lg:basis-24 h-1 rounded-lg appearance-none cursor-pointer bg-n-slate-12/30 accent-n-slate-11"
-      @input="seek"
-    />
-    <span class="text-sm tabular-nums text-n-slate-11 shrink-0">
-      {{ displayedTime }}
-    </span>
-    <div class="w-px h-3.5 bg-n-slate-6 shrink-0" />
-    <Button
-      variant="ghost"
-      color="slate"
-      size="xs"
-      :label="playbackSpeedLabel"
-      class="!px-1 min-w-6 !text-n-slate-11"
-      @click="changePlaybackSpeed"
-    />
-    <div class="w-px h-3.5 bg-n-slate-6 shrink-0" />
-    <Button
-      variant="ghost"
-      color="slate"
-      size="xs"
-      class="!w-6 !p-0 text-n-slate-11"
-      @click="downloadRecording"
-    >
-      <template #icon>
-        <Icon icon="i-lucide-download" class="size-4 flex-shrink-0" />
-      </template>
-    </Button>
-  </div>
-</template>

app/javascript/dashboard/components-next/Calls/CallStatusBadge.vue

@@ -1,56 +0,0 @@
-<script setup>
-import { computed } from 'vue';
-import { useI18n } from 'vue-i18n';
-import Icon from 'dashboard/components-next/icon/Icon.vue';
-import { CALL_KIND } from './constants';
-
-const props = defineProps({
-  kind: {
-    type: String,
-    required: true,
-  },
-});
-
-const { t } = useI18n();
-
-const KIND_CONFIG = {
-  [CALL_KIND.ONGOING]: {
-    icon: 'i-lucide-phone-call',
-    class: 'bg-n-teal-3 text-n-teal-11',
-  },
-  [CALL_KIND.INCOMING]: {
-    icon: 'i-lucide-phone-incoming',
-    class: 'bg-n-slate-3 text-n-slate-11',
-  },
-  [CALL_KIND.OUTGOING]: {
-    icon: 'i-lucide-phone-outgoing',
-    class: 'bg-n-slate-3 text-n-slate-11',
-  },
-  [CALL_KIND.MISSED]: {
-    icon: 'i-lucide-phone-missed',
-    class: 'bg-n-ruby-3 text-n-ruby-11',
-  },
-  [CALL_KIND.NO_REPLY]: {
-    icon: 'i-lucide-phone-outgoing',
-    class: 'bg-n-amber-3 text-n-amber-11',
-  },
-  [CALL_KIND.FAILED]: {
-    icon: 'i-lucide-phone-off',
-    class: 'bg-n-ruby-3 text-n-ruby-11',
-  },
-};
-
-const config = computed(() => KIND_CONFIG[props.kind]);
-</script>
-
-<template>
-  <span
-    class="inline-flex items-center justify-center w-20 gap-1.5 h-6 px-1 rounded-md text-label-small shrink-0"
-    :class="config.class"
-  >
-    <Icon :icon="config.icon" class="size-3 flex-shrink-0" />
-    <span class="truncate">{{
-      t(`CALLS_PAGE.STATUS.${kind.toUpperCase()}`)
-    }}</span>
-  </span>
-</template>

app/javascript/dashboard/components-next/Calls/CallsEmptyState.vue

@@ -1,34 +0,0 @@
-<script setup>
-import { useRoute, useRouter } from 'vue-router';
-import { useI18n } from 'vue-i18n';
-import EmptyStateLayout from 'dashboard/components-next/EmptyStateLayout.vue';
-import Button from 'dashboard/components-next/button/Button.vue';
-
-const { t } = useI18n();
-const route = useRoute();
-const router = useRouter();
-
-const setupVoiceChannel = () => {
-  router.push({
-    name: 'settings_inbox_new',
-    params: { accountId: route.params.accountId },
-  });
-};
-</script>
-
-<template>
-  <EmptyStateLayout
-    :title="t('CALLS_PAGE.SETUP.TITLE')"
-    :subtitle="t('CALLS_PAGE.SETUP.SUBTITLE')"
-    :show-backdrop="false"
-    :action-perms="['administrator']"
-  >
-    <template #actions>
-      <Button
-        :label="t('CALLS_PAGE.SETUP.ACTION')"
-        icon="i-lucide-plus"
-        @click="setupVoiceChannel"
-      />
-    </template>
-  </EmptyStateLayout>
-</template>

app/javascript/dashboard/components-next/Calls/CallsFilterBar.vue

@@ -1,270 +0,0 @@
-<script setup>
-import { computed, ref } from 'vue';
-import { OnClickOutside } from '@vueuse/components';
-import { useI18n } from 'vue-i18n';
-import Button from 'dashboard/components-next/button/Button.vue';
-import DropdownMenu from 'dashboard/components-next/dropdown-menu/DropdownMenu.vue';
-import Icon from 'dashboard/components-next/icon/Icon.vue';
-import Avatar from 'dashboard/components-next/avatar/Avatar.vue';
-
-const props = defineProps({
-  // Null while a fetch is in flight so stale counts are never shown.
-  totalCount: {
-    type: Number,
-    default: null,
-  },
-  agents: {
-    type: Array,
-    default: () => [],
-  },
-  inboxes: {
-    type: Array,
-    default: () => [],
-  },
-  // Self-scoped viewers only ever see their own calls, so the assignee filter
-  // is meaningless for them — only admins get it.
-  showAssignee: {
-    type: Boolean,
-    default: false,
-  },
-});
-
-const activity = defineModel('activity', { type: String, default: null });
-const assigneeId = defineModel('assigneeId', { type: Number, default: null });
-const inboxId = defineModel('inboxId', { type: Number, default: null });
-
-const { t } = useI18n();
-
-const ACTIVITY_ICONS = {
-  missed: 'i-lucide-phone-missed',
-  no_reply: 'i-lucide-phone-outgoing',
-  incoming: 'i-lucide-phone-incoming',
-  outgoing: 'i-lucide-phone-outgoing',
-  in_progress: 'i-lucide-phone-call',
-};
-
-const BASE_ACTIVITIES = ['missed', 'no_reply'];
-const OTHER_ACTIVITIES = ['incoming', 'outgoing', 'in_progress'];
-
-// A single open-menu identifier keeps the three dropdowns mutually exclusive:
-// opening one closes the others without any cross-wiring.
-const openMenu = ref(null); // 'activity' | 'assignee' | 'more' | null
-
-const toggleMenu = name => {
-  openMenu.value = openMenu.value === name ? null : name;
-};
-
-// Each dropdown wrapper closes itself on outside clicks. The guard keeps the
-// other two wrappers (which the click is also outside of) from closing a
-// menu the user is interacting with.
-const closeOnOutside = name => {
-  if (openMenu.value === name) openMenu.value = null;
-};
-
-const activityLabel = value => t(`CALLS_PAGE.FILTERS.${value.toUpperCase()}`);
-
-const activeChipLabel = computed(() => {
-  const label = activityLabel(activity.value);
-  return props.totalCount === null ? label : `${label} (${props.totalCount})`;
-});
-
-const inactiveChips = computed(() =>
-  BASE_ACTIVITIES.filter(value => value !== activity.value)
-);
-
-const otherActivityItems = computed(() =>
-  OTHER_ACTIVITIES.map(value => ({
-    label: activityLabel(value),
-    value,
-    action: 'filter',
-    icon: ACTIVITY_ICONS[value],
-    isSelected: activity.value === value,
-  }))
-);
-
-const assigneeItems = computed(() => [
-  {
-    label: t('CALLS_PAGE.FILTERS.ALL_ASSIGNEES'),
-    value: null,
-    action: 'filter',
-    isSelected: !assigneeId.value,
-  },
-  ...props.agents.map(agent => ({
-    label: agent.name,
-    value: agent.id,
-    action: 'filter',
-    thumbnail: { name: agent.name, src: agent.thumbnail },
-    isSelected: assigneeId.value === agent.id,
-  })),
-]);
-
-const moreFiltersSections = computed(() => [
-  {
-    title: t('CALLS_PAGE.FILTERS.INBOX'),
-    items: [
-      {
-        label: t('CALLS_PAGE.FILTERS.ALL_INBOXES'),
-        value: null,
-        action: 'inbox',
-        isSelected: !inboxId.value,
-      },
-      ...props.inboxes.map(inbox => ({
-        label: inbox.name,
-        value: inbox.id,
-        action: 'inbox',
-        isSelected: inboxId.value === inbox.id,
-      })),
-    ],
-  },
-]);
-
-const selectedAssignee = computed(
-  () => props.agents.find(agent => agent.id === assigneeId.value) || null
-);
-
-const selectedAssigneeLabel = computed(
-  () => selectedAssignee.value?.name || t('CALLS_PAGE.FILTERS.ASSIGNEE')
-);
-
-const isOtherActivitySelected = computed(() =>
-  OTHER_ACTIVITIES.includes(activity.value)
-);
-
-const hasMoreFilters = computed(() => Boolean(inboxId.value));
-
-const setActivity = value => {
-  openMenu.value = null;
-  activity.value = value;
-};
-
-const setAssignee = ({ value }) => {
-  openMenu.value = null;
-  assigneeId.value = value;
-};
-
-const applyMoreFilter = ({ action, value }) => {
-  openMenu.value = null;
-  if (action === 'inbox') inboxId.value = value;
-};
-</script>
-
-<template>
-  <div class="flex flex-wrap items-center justify-between gap-3">
-    <div class="flex flex-wrap items-center gap-2">
-      <span v-if="!activity" class="text-heading-3 text-n-slate-11 shrink-0">
-        {{
-          totalCount === null
-            ? t('CALLS_PAGE.ALL_CALLS')
-            : t('CALLS_PAGE.ALL_CALLS_COUNT', { count: totalCount })
-        }}
-      </span>
-      <Button
-        v-else
-        variant="outline"
-        color="blue"
-        size="sm"
-        :icon="ACTIVITY_ICONS[activity]"
-        class="shrink-0 !h-7 !px-2"
-        @click="setActivity(null)"
-      >
-        {{ activeChipLabel }}
-        <Icon icon="i-lucide-x" />
-      </Button>
-      <div class="w-px h-3.5 mx-1 bg-n-strong shrink-0" />
-      <Button
-        v-for="chip in inactiveChips"
-        :key="chip"
-        variant="outline"
-        color="slate"
-        size="sm"
-        :icon="ACTIVITY_ICONS[chip]"
-        :label="activityLabel(chip)"
-        class="shrink-0 text-n-slate-11 !h-7 !px-2"
-        @click="setActivity(chip)"
-      />
-      <OnClickOutside
-        class="relative shrink-0"
-        @trigger="closeOnOutside('activity')"
-      >
-        <Button
-          variant="outline"
-          color="slate"
-          size="sm"
-          icon="i-lucide-phone"
-          class="!h-7 !px-2"
-          :class="
-            isOtherActivitySelected ? 'text-n-slate-12' : 'text-n-slate-11'
-          "
-          @click="toggleMenu('activity')"
-        >
-          {{ t('CALLS_PAGE.FILTERS.OTHER_ACTIVITY') }}
-          <Icon icon="i-lucide-chevron-down" class="text-n-slate-11" />
-        </Button>
-        <DropdownMenu
-          v-if="openMenu === 'activity'"
-          :menu-items="otherActivityItems"
-          class="mt-1 start-0 top-full w-44"
-          @action="setActivity($event.value)"
-        />
-      </OnClickOutside>
-    </div>
-    <div class="flex items-center gap-2 shrink-0">
-      <OnClickOutside
-        v-if="showAssignee"
-        class="relative"
-        @trigger="closeOnOutside('assignee')"
-      >
-        <Button
-          variant="outline"
-          color="slate"
-          size="sm"
-          icon="i-woot-empty-assignee"
-          class="max-w-52 !h-7 !px-2"
-          :class="assigneeId ? 'text-n-slate-12' : 'text-n-slate-11'"
-          @click="toggleMenu('assignee')"
-        >
-          <template v-if="selectedAssignee" #icon>
-            <Avatar
-              :src="selectedAssignee.thumbnail"
-              :name="selectedAssignee.name"
-              :size="16"
-              rounded-full
-            />
-          </template>
-          <span class="truncate">{{ selectedAssigneeLabel }}</span>
-          <Icon icon="i-lucide-chevron-down" class="text-n-slate-11 shrink-0" />
-        </Button>
-        <DropdownMenu
-          v-if="openMenu === 'assignee'"
-          :menu-items="assigneeItems"
-          show-search
-          class="mt-1 end-0 top-full w-56 max-h-72"
-          @action="setAssignee"
-        />
-      </OnClickOutside>
-      <OnClickOutside class="relative" @trigger="closeOnOutside('more')">
-        <Button
-          variant="outline"
-          size="sm"
-          icon="i-lucide-list-filter"
-          class="!h-7 !px-2"
-          :color="hasMoreFilters ? 'blue' : 'slate'"
-          :class="hasMoreFilters ? '' : 'text-n-slate-11'"
-          @click="toggleMenu('more')"
-        >
-          {{ t('CALLS_PAGE.FILTERS.MORE_FILTERS') }}
-          <Icon
-            icon="i-lucide-chevron-down"
-            :class="hasMoreFilters ? '' : 'text-n-slate-11'"
-          />
-        </Button>
-        <DropdownMenu
-          v-if="openMenu === 'more'"
-          :menu-sections="moreFiltersSections"
-          class="mt-1 end-0 top-full w-56 max-h-80"
-          @action="applyMoreFilter"
-        />
-      </OnClickOutside>
-    </div>
-  </div>
-</template>

app/javascript/dashboard/components-next/Calls/constants.js

@@ -1,51 +0,0 @@
-import {
-  VOICE_CALL_STATUS,
-  VOICE_CALL_DIRECTION,
-} from 'dashboard/components-next/message/constants';
-
-export const CALL_KIND = {
-  ONGOING: 'ongoing',
-  INCOMING: 'incoming',
-  OUTGOING: 'outgoing',
-  MISSED: 'missed',
-  NO_REPLY: 'no_reply',
-  FAILED: 'failed',
-};
-
-// The API returns display values: status (ringing/in-progress/completed/
-// no-answer/failed) and direction (inbound/outbound). The list UI presents
-// them as a single "kind" per row.
-export const getCallKind = call => {
-  if (
-    [VOICE_CALL_STATUS.RINGING, VOICE_CALL_STATUS.IN_PROGRESS].includes(
-      call.status
-    )
-  ) {
-    return CALL_KIND.ONGOING;
-  }
-  if (
-    [VOICE_CALL_STATUS.FAILED, VOICE_CALL_STATUS.REJECTED].includes(call.status)
-  ) {
-    return CALL_KIND.FAILED;
-  }
-  const isInbound = call.direction === VOICE_CALL_DIRECTION.INBOUND;
-  if (call.status === VOICE_CALL_STATUS.NO_ANSWER) {
-    return isInbound ? CALL_KIND.MISSED : CALL_KIND.NO_REPLY;
-  }
-  return isInbound ? CALL_KIND.INCOMING : CALL_KIND.OUTGOING;
-};
-
-// Filter chips map to the status/direction params supported by CallFinder.
-export const CALL_ACTIVITY_PARAMS = {
-  missed: {
-    status: VOICE_CALL_STATUS.NO_ANSWER,
-    direction: VOICE_CALL_DIRECTION.INBOUND,
-  },
-  no_reply: {
-    status: VOICE_CALL_STATUS.NO_ANSWER,
-    direction: VOICE_CALL_DIRECTION.OUTBOUND,
-  },
-  incoming: { direction: VOICE_CALL_DIRECTION.INBOUND },
-  outgoing: { direction: VOICE_CALL_DIRECTION.OUTBOUND },
-  in_progress: { status: VOICE_CALL_STATUS.IN_PROGRESS },
-};

app/javascript/dashboard/components-next/Campaigns/CampaignCard/CampaignCard.vue

@@ -83,12 +83,8 @@ const campaignStatus = computed(() => {
 const inboxName = computed(() => props.inbox?.name || '');
 
 const inboxIcon = computed(() => {
-  const {
-    medium,
-    channel_type: type,
-    voice_enabled: voiceEnabled,
-  } = props.inbox;
-  return getInboxIconByType(type, medium, 'fill', voiceEnabled);
+  const { medium, channel_type: type } = props.inbox;
+  return getInboxIconByType(type, medium);
 });
 </script>
 

app/javascript/dashboard/components-next/Contacts/VoiceCallButton.vue

@@ -16,6 +16,7 @@ import { useAlert } from 'dashboard/composables';
 import { frontendURL, conversationUrl } from 'dashboard/helper/URLHelper';
 import { useCallsStore } from 'dashboard/stores/calls';
 import { useWhatsappCallSession } from 'dashboard/composables/useWhatsappCallSession';
+import ContactAPI from 'dashboard/api/contacts';
 
 import Button from 'dashboard/components-next/button/Button.vue';
 import Dialog from 'dashboard/components-next/dialog/Dialog.vue';
@@ -82,18 +83,39 @@ const navigateToConversation = conversationId => {
 
 const whatsappCallSession = useWhatsappCallSession();
 
+// Find the most recent open conversation for this contact in the picked inbox.
+// WhatsApp /initiate is conversation-scoped (unlike Twilio's contact-scoped path).
+// Pass inboxId so the BE applies the filter before the 20-row cap — without it,
+// contacts whose latest WhatsApp conversation falls outside the 20 most recent
+// across all inboxes would be treated as having no conversation.
+const findWhatsappConversationId = async inboxId => {
+  const { data } = await ContactAPI.getConversations(props.contactId, {
+    inboxId,
+  });
+  const conversations = data?.payload || [];
+  const match = [...conversations].sort(
+    (a, b) => (b.last_activity_at || 0) - (a.last_activity_at || 0)
+  )[0];
+  return match?.id || null;
+};
+
 const startWhatsappCall = async (inboxId, conversationIdHint) => {
-  const response = await whatsappCallSession.initiateOutboundCall(
-    conversationIdHint
-      ? { conversationId: conversationIdHint }
-      : { contactId: props.contactId, inboxId }
-  );
+  // WhatsApp /initiate is conversation-scoped, so we must hand it a
+  // conversation. Use the caller's hint when given (in-conversation flow);
+  // otherwise pick the most recent one in the inbox.
+  const conversationId =
+    conversationIdHint || (await findWhatsappConversationId(inboxId));
+  if (!conversationId) {
+    useAlert(t('CONTACT_PANEL.CALL_FAILED'));
+    return;
+  }
+
+  const response =
+    await whatsappCallSession.initiateOutboundCall(conversationId);
   // The composable returns { status: 'locked' } when an init is already in
   // flight or a call is already active; treat that as a soft no-op rather than
   // claiming success.
   if (response?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.LOCKED) return;
-
-  const conversationId = response?.conversation_id || conversationIdHint;
   if (!response?.id) {
     // Permission template path returns no call id. Mirror the header button and
     // surface whether the request was just sent or is already pending instead of

app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCard.vue

@@ -48,8 +48,8 @@ const inbox = computed(() => props.stateInbox);
 const inboxName = computed(() => inbox.value?.name);
 
 const inboxIcon = computed(() => {
-  const { channelType, medium, voiceEnabled } = inbox.value;
-  return getInboxIconByType(channelType, medium, 'fill', voiceEnabled);
+  const { channelType, medium } = inbox.value;
+  return getInboxIconByType(channelType, medium);
 });
 
 const lastActivityAt = computed(() => {

app/javascript/dashboard/components-next/HelpCenter/ArticleCard/ArticleCard.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { computed, useTemplateRef } from 'vue';
+import { computed } from 'vue';
 import { useToggle } from '@vueuse/core';
 import { useI18n } from 'vue-i18n';
 import { dynamicTime } from 'shared/helpers/timeHelper';
@@ -7,9 +7,7 @@ import {
   ARTICLE_MENU_ITEMS,
   ARTICLE_MENU_OPTIONS,
   ARTICLE_STATUSES,
-  getArticleStatus,
 } from 'dashboard/helper/portalHelper';
-import ArticlePendingChangesPopover from 'dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticlePendingChangesPopover.vue';
 
 import { useMapGetter } from 'dashboard/composables/store.js';
 import { useConfig } from 'dashboard/composables/useConfig';
@@ -55,10 +53,6 @@ const props = defineProps({
     type: Boolean,
     default: false,
   },
-  hasPendingChanges: {
-    type: Boolean,
-    default: false,
-  },
   selectable: {
     type: Boolean,
     default: false,
@@ -74,16 +68,12 @@ const emit = defineEmits([
   'articleAction',
   'toggleSelect',
   'hover',
-  'draftResolved',
-  'draftFailed',
 ]);
 
 const { t } = useI18n();
 
 const [showActionsDropdown, toggleDropdown] = useToggle();
 
-const pendingChangesPopoverRef = useTemplateRef('pendingChangesPopoverRef');
-
 const currentAccountId = useMapGetter('getCurrentAccountId');
 const isFeatureEnabledonAccount = useMapGetter(
   'accounts/isFeatureEnabledonAccount'
@@ -115,18 +105,7 @@ const articleMenuItems = computed(() => {
     .filter(key => key !== 'translate' || isTranslationAvailable.value)
     .map(key => commonItems[key]);
 
-  const draftItems = props.hasPendingChanges
-    ? [
-        {
-          label: t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.DISCARD_CHANGES'),
-          value: 'discard-draft',
-          action: 'discard-draft',
-          icon: 'i-lucide-undo-2',
-        },
-      ]
-    : [];
-
-  return [...statusItems, ...draftItems, commonItems.delete];
+  return [...statusItems, commonItems.delete];
 });
 
 const statusTextColor = computed(() => {
@@ -174,12 +153,6 @@ const lastUpdatedAt = computed(() => {
 
 const handleArticleAction = ({ action, value }) => {
   toggleDropdown(false);
-  // Un-publishing an article with staged edits — confirm apply/discard first;
-  // the popover applies the chosen status itself.
-  if (props.hasPendingChanges && (action === 'draft' || action === 'archive')) {
-    pendingChangesPopoverRef.value?.open(getArticleStatus(value));
-    return;
-  }
   emit('articleAction', { action, value, id: props.id });
 };
 
@@ -211,18 +184,6 @@ const handleClick = id => {
         </span>
       </div>
       <div class="flex items-center gap-2">
-        <span
-          v-if="hasPendingChanges"
-          :title="
-            t(
-              'HELP_CENTER.ARTICLES_PAGE.ARTICLE_CARD.CARD.PENDING_EDITS_TOOLTIP'
-            )
-          "
-          class="text-xs font-medium inline-flex items-center gap-1 h-6 px-2 py-0.5 rounded-md text-n-slate-11 bg-n-alpha-2 whitespace-nowrap shrink-0"
-        >
-          <span class="rounded-full size-1.5 bg-n-amber-9 shrink-0" />
-          {{ t('HELP_CENTER.ARTICLES_PAGE.ARTICLE_CARD.CARD.PENDING_EDITS') }}
-        </span>
         <span
           class="text-xs font-medium inline-flex items-center h-6 px-2 py-0.5 rounded-md bg-n-alpha-2"
           :class="statusTextColor"
@@ -243,15 +204,9 @@ const handleClick = id => {
           <DropdownMenu
             v-if="showActionsDropdown"
             :menu-items="articleMenuItems"
-            class="mt-1 end-0 top-full w-40"
+            class="mt-1 ltr:right-0 rtl:left-0 xl:ltr:left-0 xl:rtl:right-0 top-full"
             @action="handleArticleAction($event)"
           />
-          <ArticlePendingChangesPopover
-            ref="pendingChangesPopoverRef"
-            :article-id="id"
-            @resolved="emit('draftResolved', $event)"
-            @failed="emit('draftFailed', $event)"
-          />
         </div>
       </div>
     </div>

app/javascript/dashboard/components-next/HelpCenter/LocaleCard/LocaleCard.vue

@@ -56,9 +56,6 @@ const localeMenuLabels = computed(() => ({
   'customize-content': t(
     'HELP_CENTER.LOCALES_PAGE.LOCALE_CARD.DROPDOWN_MENU.CUSTOMIZE_CONTENT'
   ),
-  'select-popular-content': t(
-    'HELP_CENTER.LOCALES_PAGE.LOCALE_CARD.DROPDOWN_MENU.SELECT_POPULAR_CONTENT'
-  ),
   delete: t('HELP_CENTER.LOCALES_PAGE.LOCALE_CARD.DROPDOWN_MENU.DELETE'),
 }));
 

app/javascript/dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleDiffPanel.vue

@@ -1,173 +0,0 @@
-<script setup>
-import { computed } from 'vue';
-import { useI18n } from 'vue-i18n';
-import { vOnClickOutside } from '@vueuse/components';
-import { useKeyboardEvents } from 'dashboard/composables/useKeyboardEvents';
-import MessageFormatter from 'shared/helpers/MessageFormatter';
-import {
-  renderInlineDiff,
-  buildDiffBlocks,
-} from 'dashboard/helper/articleDiffHelper';
-
-import Button from 'dashboard/components-next/button/Button.vue';
-import TeleportWithDirection from 'dashboard/components-next/TeleportWithDirection.vue';
-
-const props = defineProps({
-  article: {
-    type: Object,
-    default: () => ({}),
-  },
-});
-
-const isOpen = defineModel({ type: Boolean, default: false });
-
-const { t } = useI18n();
-
-const liveTitle = computed(() => props.article?.title ?? '');
-const liveContent = computed(() => props.article?.content ?? '');
-const draftTitle = computed(() => props.article?.draftTitle ?? liveTitle.value);
-const draftContent = computed(
-  () => props.article?.draftContent ?? liveContent.value
-);
-
-const titleChanged = computed(() => liveTitle.value !== draftTitle.value);
-const titleDiff = computed(() =>
-  renderInlineDiff(liveTitle.value, draftTitle.value)
-);
-
-const contentBlocks = computed(() =>
-  buildDiffBlocks(liveContent.value, draftContent.value)
-);
-const contentChanged = computed(() =>
-  contentBlocks.value.some(block => block.type !== 'equal')
-);
-
-// HC tables store per-column widths (px, 0 = unset) in this marker, which the
-// formatter strips. Re-apply them as a fixed-layout <colgroup>, defaulting
-// unsized columns so they don't collapse.
-const COLWIDTHS_RE = /<!--cw-colwidths:([\d,]+)-->/;
-const DEFAULT_COL_WIDTH = 50;
-
-const applyColumnWidths = (html, widths) => {
-  const doc = new DOMParser().parseFromString(html, 'text/html');
-  const table = doc.body.querySelector('table');
-  if (!table) return html;
-
-  const sized = widths.map(width => (width > 0 ? width : DEFAULT_COL_WIDTH));
-  const colgroup = doc.createElement('colgroup');
-  sized.forEach(width => {
-    const col = doc.createElement('col');
-    col.style.width = `${width}px`;
-    colgroup.appendChild(col);
-  });
-  table.insertBefore(colgroup, table.firstChild);
-
-  table.style.tableLayout = 'fixed';
-  table.style.width = `${sized.reduce((sum, width) => sum + width, 0)}px`;
-  return doc.body.innerHTML;
-};
-
-const renderMarkdown = markdown => {
-  if (!markdown) return '';
-  const html = new MessageFormatter(markdown).formattedMessage;
-  const match = markdown.match(COLWIDTHS_RE);
-  return match
-    ? applyColumnWidths(html, match[1].split(',').map(Number))
-    : html;
-};
-
-const blockClass = type => {
-  if (type === 'added') {
-    return 'border-n-teal-9 bg-n-teal-2';
-  }
-  if (type === 'removed') {
-    return 'border-n-ruby-9 bg-n-ruby-2 line-through decoration-n-ruby-9/50';
-  }
-  return 'border-transparent';
-};
-
-const close = () => {
-  isOpen.value = false;
-};
-
-const dismissOnClickOutside = [close, { ignore: ['[data-diff-toggle]'] }];
-
-useKeyboardEvents({ Escape: { action: close, allowOnFocusedInput: true } });
-</script>
-
-<template>
-  <TeleportWithDirection to="body">
-    <Transition
-      enter-active-class="transition-transform duration-200 ease-in-out"
-      leave-active-class="transition-transform duration-200 ease-in-out"
-      enter-from-class="ltr:translate-x-full rtl:-translate-x-full"
-      enter-to-class="ltr:translate-x-0 rtl:-translate-x-0"
-      leave-from-class="ltr:translate-x-0 rtl:-translate-x-0"
-      leave-to-class="ltr:translate-x-full rtl:-translate-x-full"
-    >
-      <aside
-        v-if="isOpen"
-        v-on-click-outside="dismissOnClickOutside"
-        class="fixed inset-y-0 z-40 flex flex-col w-full shadow-2xl end-0 max-w-lg bg-n-solid-2 ltr:border-l rtl:border-r border-n-weak"
-      >
-        <header
-          class="flex items-start justify-between gap-3 px-6 py-4 border-b shrink-0 border-n-weak bg-n-solid-1"
-        >
-          <div class="flex flex-col gap-1 min-w-0">
-            <div class="flex items-center gap-2">
-              <span class="size-2 rounded-full bg-n-amber-9 shrink-0" />
-              <h3 class="text-base font-medium leading-6 text-n-slate-12">
-                {{ t('HELP_CENTER.EDIT_ARTICLE_PAGE.DIFF_DIALOG.TITLE') }}
-              </h3>
-            </div>
-            <p class="text-sm text-n-slate-11">
-              {{ t('HELP_CENTER.EDIT_ARTICLE_PAGE.DIFF_DIALOG.DESCRIPTION') }}
-            </p>
-          </div>
-          <Button
-            icon="i-lucide-x"
-            variant="ghost"
-            color="slate"
-            size="sm"
-            class="shrink-0 hover:text-n-slate-11"
-            @click="close"
-          />
-        </header>
-
-        <div
-          class="flex flex-col flex-1 min-h-0 gap-4 px-6 pt-4 pb-6 overflow-y-auto"
-        >
-          <!-- eslint-disable vue/no-v-html -->
-          <div
-            v-if="titleChanged"
-            class="flex flex-col gap-1.5 border-s-[3px] border-transparent ps-3"
-          >
-            <span
-              class="text-[11px] font-medium tracking-wide uppercase text-n-slate-10"
-            >
-              {{ t('HELP_CENTER.EDIT_ARTICLE_PAGE.DIFF_DIALOG.TITLE_LABEL') }}
-            </span>
-            <h1
-              class="text-lg font-semibold leading-snug text-n-slate-12"
-              v-html="titleDiff"
-            />
-          </div>
-
-          <div
-            v-if="contentChanged"
-            class="flex flex-col gap-1 [&_table]:w-full [&_table]:border-collapse [&_th]:border [&_td]:border [&_th]:border-n-weak [&_td]:border-n-weak [&_th]:p-2 [&_td]:p-2 [&_th]:bg-n-alpha-1 [&_th]:text-start [&_td]:align-top"
-          >
-            <div
-              v-for="(block, index) in contentBlocks"
-              :key="index"
-              class="px-3 py-1.5 overflow-x-auto text-sm leading-relaxed break-words border-s-[3px] rounded-e-md text-n-slate-12 prose-sm prose dark:prose-invert max-w-none [&_p]:my-0 [&>:first-child]:mt-0 [&>:last-child]:mb-0"
-              :class="blockClass(block.type)"
-              v-html="renderMarkdown(block.md)"
-            />
-          </div>
-          <!-- eslint-enable vue/no-v-html -->
-        </div>
-      </aside>
-    </Transition>
-  </TeleportWithDirection>
-</template>

app/javascript/dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleEditor.vue

@@ -1,6 +1,6 @@
 <script setup>
-import { ref, computed, watch, onBeforeUnmount } from 'vue';
-import { useTimeoutFn } from '@vueuse/core';
+import { ref, computed, watch } from 'vue';
+import { debounce } from '@chatwoot/utils';
 import { useI18n } from 'vue-i18n';
 import { ARTICLE_EDITOR_MENU_OPTIONS } from 'dashboard/constants/editor';
 
@@ -9,7 +9,6 @@ import TextArea from 'dashboard/components-next/textarea/TextArea.vue';
 import FullEditor from 'dashboard/components/widgets/WootWriter/FullEditor.vue';
 import ArticleEditorHeader from 'dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleEditorHeader.vue';
 import ArticleEditorControls from 'dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleEditorControls.vue';
-import ArticleDiffPanel from 'dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleDiffPanel.vue';
 
 const props = defineProps({
   article: {
@@ -39,75 +38,32 @@ const { t } = useI18n();
 
 const isNewArticle = computed(() => !props.article?.id);
 
-// Prefer the draft; `??` keeps a deliberately-cleared empty string instead of
-// falling back to the live value.
-const effectiveTitle = () =>
-  props.article?.draftTitle ?? props.article?.title ?? '';
-const effectiveContent = () =>
-  props.article?.draftContent ?? props.article?.content ?? '';
+const localTitle = ref(props.article?.title ?? '');
+const localContent = ref(props.article?.content ?? '');
 
-const hasPendingChanges = computed(
-  () => props.article?.draftTitle != null || props.article?.draftContent != null
-);
-
-const localTitle = ref(effectiveTitle());
-const localContent = ref(effectiveContent());
-
-const isDiffPanelOpen = ref(false);
-
-// Autosave 500ms after the last edit. It sends both title and content so an
-// edit to one never drops a recent edit to the other. `stop` cancels a queued
-// save; `isPending` tells the header to wait before allowing a publish.
-const {
-  isPending: isSaving,
-  start: debouncedSave,
-  stop: cancelSave,
-} = useTimeoutFn(
-  () =>
-    emit('saveArticle', {
-      title: localTitle.value,
-      content: localContent.value,
-    }),
-  500,
-  { immediate: false }
-);
-
-const syncLocalState = () => {
-  cancelSave();
-  localTitle.value = effectiveTitle();
-  localContent.value = effectiveContent();
-};
-
-// Reseed on article switch or once a draft is published/discarded; close the
-// diff panel in the latter case since there's nothing left to compare.
+// Sync local state when navigating to a different article or on initial fetch
 watch(
-  [() => props.article?.id, hasPendingChanges],
-  ([id, pending], [prevId, prevPending]) => {
-    if ((id && id !== prevId) || (prevPending && !pending)) syncLocalState();
-    if (prevPending && !pending) isDiffPanelOpen.value = false;
+  () => props.article?.id,
+  newId => {
+    if (newId) {
+      localTitle.value = props.article?.title ?? '';
+      localContent.value = props.article?.content ?? '';
+    }
   }
 );
 
-const scheduleSave = () => {
-  if (isNewArticle.value) return;
-  debouncedSave();
-};
+const debouncedSave = debounce(value => emit('saveArticle', value), 500, false);
 
-// Flush a queued save on unmount so leaving the editor doesn't drop the last edit.
-onBeforeUnmount(() => {
-  if (isNewArticle.value || !isSaving.value) return;
-  cancelSave();
-  emit('saveArticle', {
-    title: localTitle.value,
-    content: localContent.value,
-  });
-});
+const handleSave = value => {
+  if (isNewArticle.value) return;
+  debouncedSave(value);
+};
 
 const articleTitle = computed({
   get: () => localTitle.value,
   set: value => {
     localTitle.value = value;
-    scheduleSave();
+    handleSave({ title: value });
   },
 });
 
@@ -115,7 +71,7 @@ const articleContent = computed({
   get: () => localContent.value,
   set: content => {
     localContent.value = content;
-    scheduleSave();
+    handleSave({ content });
   },
 });
 
@@ -152,13 +108,9 @@ const handleCreateArticle = event => {
         :is-saved="isSaved"
         :status="article.status"
         :article-id="article.id"
-        :pending-changes="hasPendingChanges"
-        :is-saving="isSaving"
         @go-back="onClickGoBack"
         @preview-article="previewArticle"
-        @show-diff="isDiffPanelOpen = !isDiffPanelOpen"
       />
-      <ArticleDiffPanel v-model="isDiffPanelOpen" :article="article" />
     </template>
     <template #content>
       <div class="flex flex-col gap-3 pl-4 mb-3 rtl:pr-3 rtl:pl-0">

app/javascript/dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleEditorHeader.vue

@@ -1,8 +1,8 @@
 <script setup>
-import { computed, ref, useTemplateRef } from 'vue';
+import { computed, ref } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRoute } from 'vue-router';
-import { useStore, useMapGetter } from 'dashboard/composables/store.js';
+import { useStore } from 'dashboard/composables/store.js';
 import { useAlert, useTrack } from 'dashboard/composables';
 import { PORTALS_EVENTS } from 'dashboard/helper/AnalyticsHelper/events';
 import { OnClickOutside } from '@vueuse/components';
@@ -17,7 +17,6 @@ import wootConstants from 'dashboard/constants/globals';
 import ButtonGroup from 'dashboard/components-next/buttonGroup/ButtonGroup.vue';
 import Button from 'dashboard/components-next/button/Button.vue';
 import DropdownMenu from 'dashboard/components-next/dropdown-menu/DropdownMenu.vue';
-import ArticlePendingChangesPopover from 'dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticlePendingChangesPopover.vue';
 
 const props = defineProps({
   isUpdating: {
@@ -36,17 +35,9 @@ const props = defineProps({
     type: Number,
     default: 0,
   },
-  pendingChanges: {
-    type: Boolean,
-    default: false,
-  },
-  isSaving: {
-    type: Boolean,
-    default: false,
-  },
 });
 
-const emit = defineEmits(['goBack', 'previewArticle', 'showDiff']);
+const emit = defineEmits(['goBack', 'previewArticle']);
 
 const { t } = useI18n();
 const store = useStore();
@@ -58,30 +49,9 @@ const { ARTICLE_STATUS_TYPES } = wootConstants;
 
 const showArticleActionMenu = ref(false);
 
-const pendingChangesPopoverRef = useTemplateRef('pendingChangesPopoverRef');
-
-// Per-article update flag the store already maintains.
-const articleUiFlags = useMapGetter('articles/uiFlags');
-const isUpdatingArticle = computed(
-  () => articleUiFlags.value(props.articleId).isUpdating
-);
-
-// Publishing while a save is still in flight would promote a stale draft, so we show an alert
-const blockedWhileSaving = () => {
-  if (!props.isSaving && !isUpdatingArticle.value) return false;
-  useAlert(t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.SAVE_IN_PROGRESS'));
-  return true;
-};
-
-const isPublished = computed(() => props.status === ARTICLE_STATUSES.PUBLISHED);
-
-const hasPendingChanges = computed(
-  () => isPublished.value && props.pendingChanges
-);
-
 const articleMenuItems = computed(() => {
   const statusOptions = ARTICLE_EDITOR_STATUS_OPTIONS[props.status] ?? [];
-  const items = statusOptions.map(option => {
+  return statusOptions.map(option => {
     const { label, value, icon } = ARTICLE_MENU_ITEMS[option];
     return {
       label: t(label),
@@ -90,17 +60,6 @@ const articleMenuItems = computed(() => {
       icon,
     };
   });
-
-  if (hasPendingChanges.value) {
-    items.push({
-      label: t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.DISCARD_CHANGES'),
-      value: 'discard-draft',
-      action: 'discard-draft',
-      icon: 'i-lucide-undo-2',
-    });
-  }
-
-  return items;
 });
 
 const statusText = computed(() =>
@@ -126,9 +85,8 @@ const getStatusMessage = (status, isSuccess) => {
     : '';
 };
 
-// Pass draftAction (publishDraft/discardDraft) to resolve a draft in the same
-// update; omit it for a plain status change.
-const performStatusUpdate = async (value, draftAction) => {
+const updateArticleStatus = async ({ value }) => {
+  showArticleActionMenu.value = false;
   const status = getArticleStatus(value);
   if (status === ARTICLE_STATUS_TYPES.PUBLISH) {
     isArticlePublishing.value = true;
@@ -136,7 +94,7 @@ const performStatusUpdate = async (value, draftAction) => {
   const { portalSlug } = route.params;
 
   try {
-    await store.dispatch(`articles/${draftAction ?? 'update'}`, {
+    await store.dispatch('articles/update', {
       portalSlug,
       articleId: props.articleId,
       status,
@@ -149,100 +107,12 @@ const performStatusUpdate = async (value, draftAction) => {
     } else if (status === ARTICLE_STATUS_TYPES.PUBLISH) {
       useTrack(PORTALS_EVENTS.PUBLISH_ARTICLE);
     }
+    isArticlePublishing.value = false;
   } catch (error) {
     useAlert(error?.message ?? getStatusMessage(status, false));
-  } finally {
     isArticlePublishing.value = false;
   }
 };
-
-const updateArticleStatus = ({ value }) => {
-  showArticleActionMenu.value = false;
-  // Leaving published with unsaved draft edits — ask whether to apply or discard
-  // first; the popover applies the status itself once resolved.
-  if (hasPendingChanges.value) {
-    pendingChangesPopoverRef.value?.open(getArticleStatus(value));
-    return;
-  }
-  performStatusUpdate(value);
-};
-
-const publishDraftChanges = async () => {
-  isArticlePublishing.value = true;
-  const { portalSlug } = route.params;
-  try {
-    await store.dispatch('articles/publishDraft', {
-      portalSlug,
-      articleId: props.articleId,
-    });
-    useAlert(t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PUBLISH_CHANGES_SUCCESS'));
-    useTrack(PORTALS_EVENTS.PUBLISH_ARTICLE);
-  } catch (error) {
-    useAlert(
-      error?.message ??
-        t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PUBLISH_CHANGES_ERROR')
-    );
-  } finally {
-    isArticlePublishing.value = false;
-  }
-};
-
-const discardDraftChanges = async () => {
-  const { portalSlug } = route.params;
-  try {
-    await store.dispatch('articles/discardDraft', {
-      portalSlug,
-      articleId: props.articleId,
-    });
-    useAlert(t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.DISCARD_CHANGES_SUCCESS'));
-  } catch (error) {
-    useAlert(
-      error?.message ??
-        t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.DISCARD_CHANGES_ERROR')
-    );
-  }
-};
-
-const onPrimaryAction = () => {
-  if (blockedWhileSaving()) return;
-  if (hasPendingChanges.value) {
-    publishDraftChanges();
-  } else if (props.pendingChanges) {
-    // Promote leftover draft edits on publish instead of republishing stale content.
-    performStatusUpdate(ARTICLE_STATUSES.PUBLISHED, 'publishDraft');
-  } else {
-    updateArticleStatus({ value: ARTICLE_STATUSES.PUBLISHED });
-  }
-};
-
-const onMenuAction = event => {
-  showArticleActionMenu.value = false;
-  // Don't resolve a draft while an autosave is still in flight — it could land
-  // after and recreate the draft we just discarded/applied.
-  if (blockedWhileSaving()) return;
-  if (event.action === 'discard-draft') {
-    discardDraftChanges();
-  } else {
-    updateArticleStatus(event);
-  }
-};
-
-// The popover applies the draft + status itself; we just surface the outcome.
-const onDraftResolved = status => {
-  useAlert(getStatusMessage(status, true));
-  if (status === ARTICLE_STATUS_TYPES.ARCHIVE) {
-    useTrack(PORTALS_EVENTS.ARCHIVE_ARTICLE, { uiFrom: 'header' });
-  } else if (status === ARTICLE_STATUS_TYPES.PUBLISH) {
-    useTrack(PORTALS_EVENTS.PUBLISH_ARTICLE);
-  }
-};
-
-const onDraftFailed = error => {
-  useAlert(
-    error?.message ??
-      t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PUBLISH_CHANGES_ERROR')
-  );
-};
 </script>
 
 <template>
@@ -257,24 +127,13 @@ const onDraftFailed = error => {
       @click="onClickGoBack"
     />
     <div class="flex items-center gap-4">
-      <button
-        v-if="hasPendingChanges"
-        type="button"
-        data-diff-toggle
-        :title="t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.VIEW_CHANGES')"
-        class="flex items-center gap-1.5 px-2 py-1 text-xs font-medium transition-colors rounded-lg cursor-pointer text-n-amber-11 bg-n-amber-3 outline outline-1 outline-n-amber-5 hover:bg-n-amber-4"
-        @click="emit('showDiff')"
-      >
-        <span class="rounded-full size-1.5 bg-n-amber-9 shrink-0" />
-        {{ t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PENDING_CHANGES') }}
-      </button>
       <span
         v-if="isUpdating || isSaved"
         class="text-xs font-medium transition-all duration-300 text-n-slate-11"
       >
         {{ statusText }}
       </span>
-      <div class="relative flex items-center gap-2">
+      <div class="flex items-center gap-2">
         <Button
           :label="t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PREVIEW')"
           color="slate"
@@ -284,21 +143,17 @@ const onDraftFailed = error => {
         />
         <ButtonGroup class="flex items-center">
           <Button
-            :label="
-              hasPendingChanges
-                ? t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PUBLISH_CHANGES')
-                : t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PUBLISH')
-            "
+            :label="t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PUBLISH')"
             size="sm"
             class="ltr:rounded-r-none rtl:rounded-l-none"
             no-animation
             :is-loading="isArticlePublishing"
             :disabled="
+              status === ARTICLE_STATUSES.PUBLISHED ||
               !articleId ||
-              isArticlePublishing ||
-              (isPublished && !hasPendingChanges)
+              isArticlePublishing
             "
-            @click="onPrimaryAction"
+            @click="updateArticleStatus({ value: ARTICLE_STATUSES.PUBLISHED })"
           />
           <div class="relative">
             <OnClickOutside @trigger="showArticleActionMenu = false">
@@ -314,17 +169,11 @@ const onDraftFailed = error => {
                 v-if="showArticleActionMenu"
                 :menu-items="articleMenuItems"
                 class="mt-2 ltr:right-0 rtl:left-0 top-full"
-                @action="onMenuAction($event)"
+                @action="updateArticleStatus($event)"
               />
             </OnClickOutside>
           </div>
         </ButtonGroup>
-        <ArticlePendingChangesPopover
-          ref="pendingChangesPopoverRef"
-          :article-id="articleId"
-          @resolved="onDraftResolved"
-          @failed="onDraftFailed"
-        />
       </div>
     </div>
   </div>

app/javascript/dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticlePendingChangesPopover.vue

@@ -1,132 +0,0 @@
-<script setup>
-import { ref, computed } from 'vue';
-import { useI18n } from 'vue-i18n';
-import { useRoute } from 'vue-router';
-import { useStore, useMapGetter } from 'dashboard/composables/store';
-import { onKeyStroke } from '@vueuse/core';
-import { vOnClickOutside } from '@vueuse/components';
-
-import Button from 'dashboard/components-next/button/Button.vue';
-
-const props = defineProps({
-  articleId: {
-    type: Number,
-    required: true,
-  },
-});
-
-const emit = defineEmits(['resolved', 'failed']);
-
-const { t } = useI18n();
-const store = useStore();
-const route = useRoute();
-
-const isOpen = ref(false);
-const requestedStatus = ref(null);
-// Which button is in flight, so only that one shows the spinner.
-const activeAction = ref(null);
-
-const articleUiFlags = useMapGetter('articles/uiFlags');
-const isLoading = computed(
-  () => articleUiFlags.value(props.articleId).isUpdating
-);
-
-// Open the confirmation for a target status; resolving it also applies that status.
-const open = status => {
-  requestedStatus.value = status;
-  activeAction.value = null;
-  isOpen.value = true;
-};
-
-const close = () => {
-  isOpen.value = false;
-};
-
-// Don't let a click-outside or Escape dismiss the popover mid-action.
-const dismiss = () => {
-  if (!isLoading.value) close();
-};
-
-const resolve = async draftAction => {
-  activeAction.value = draftAction === 'publishDraft' ? 'apply' : 'discard';
-  try {
-    await store.dispatch(`articles/${draftAction}`, {
-      portalSlug: route.params.portalSlug,
-      articleId: props.articleId,
-      status: requestedStatus.value,
-    });
-    emit('resolved', requestedStatus.value);
-    close();
-  } catch (error) {
-    emit('failed', error);
-  }
-};
-
-const onApply = () => resolve('publishDraft');
-const onDiscard = () => resolve('discardDraft');
-
-onKeyStroke('Escape', () => {
-  if (isOpen.value) dismiss();
-});
-
-defineExpose({ open, close });
-</script>
-
-<template>
-  <div
-    v-show="isOpen"
-    v-on-click-outside="dismiss"
-    class="absolute z-50 flex flex-col gap-4 p-4 mt-2 outline outline-1 shadow-lg w-96 end-0 top-full rounded-xl bg-n-alpha-3 backdrop-blur-[100px] outline-n-container"
-  >
-    <div class="flex items-start justify-between gap-2">
-      <div class="flex flex-col gap-1">
-        <h3 class="text-base font-medium text-n-slate-12">
-          {{ t('HELP_CENTER.EDIT_ARTICLE_PAGE.PENDING_CHANGES_POPOVER.TITLE') }}
-        </h3>
-        <p class="mb-0 text-sm text-n-slate-11">
-          {{
-            t(
-              'HELP_CENTER.EDIT_ARTICLE_PAGE.PENDING_CHANGES_POPOVER.DESCRIPTION'
-            )
-          }}
-        </p>
-      </div>
-      <Button
-        icon="i-lucide-x"
-        variant="ghost"
-        color="slate"
-        size="xs"
-        class="shrink-0 -me-1 -mt-1"
-        :disabled="isLoading"
-        @click="close"
-      />
-    </div>
-    <div class="flex items-center justify-between gap-2">
-      <Button
-        type="button"
-        variant="faded"
-        color="ruby"
-        size="sm"
-        class="flex-1"
-        :is-loading="isLoading && activeAction === 'discard'"
-        :disabled="isLoading"
-        :label="
-          t('HELP_CENTER.EDIT_ARTICLE_PAGE.PENDING_CHANGES_POPOVER.DISCARD')
-        "
-        @click="onDiscard"
-      />
-      <Button
-        type="button"
-        color="blue"
-        size="sm"
-        class="flex-1"
-        :is-loading="isLoading && activeAction === 'apply'"
-        :disabled="isLoading"
-        :label="
-          t('HELP_CENTER.EDIT_ARTICLE_PAGE.PENDING_CHANGES_POPOVER.APPLY')
-        "
-        @click="onApply"
-      />
-    </div>
-  </div>
-</template>

app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticleList.vue

@@ -5,12 +5,8 @@ import { useRouter, useRoute } from 'vue-router';
 import { useI18n } from 'vue-i18n';
 import { useAlert, useTrack } from 'dashboard/composables';
 import { PORTALS_EVENTS } from 'dashboard/helper/AnalyticsHelper/events';
-import {
-  getArticleStatus,
-  ARTICLE_STATUSES,
-} from 'dashboard/helper/portalHelper.js';
+import { getArticleStatus } from 'dashboard/helper/portalHelper.js';
 import wootConstants from 'dashboard/constants/globals';
-import { hasPendingChanges } from 'dashboard/helper/articleDiffHelper';
 
 import ArticleCard from 'dashboard/components-next/HelpCenter/ArticleCard/ArticleCard.vue';
 import DraggableReorderList from 'dashboard/components-next/DraggableReorderList/DraggableReorderList.vue';
@@ -149,24 +145,6 @@ const updateArticlesMeta = () => {
   });
 };
 
-const refreshArticleMeta = async () => {
-  await updateArticlesMeta();
-  await updatePortalMeta();
-};
-
-// The card's pending-changes popover applies the status itself; surface the result.
-const onDraftResolved = status => {
-  useAlert(getStatusMessage(status, true));
-  refreshArticleMeta();
-};
-
-const onDraftFailed = error => {
-  useAlert(
-    error?.message ||
-      t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.PUBLISH_CHANGES_ERROR')
-  );
-};
-
 const handleArticleAction = async (action, { status, id }) => {
   const { portalSlug } = route.params;
   try {
@@ -176,14 +154,6 @@ const handleArticleAction = async (action, { status, id }) => {
         articleId: id,
       });
       useAlert(t('HELP_CENTER.DELETE_ARTICLE.API.SUCCESS_MESSAGE'));
-    } else if (action === 'discard-draft') {
-      await store.dispatch('articles/discardDraft', {
-        portalSlug,
-        articleId: id,
-      });
-      useAlert(
-        t('HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.DISCARD_CHANGES_SUCCESS')
-      );
     } else {
       await store.dispatch('articles/update', {
         portalSlug,
@@ -198,16 +168,15 @@ const handleArticleAction = async (action, { status, id }) => {
         useTrack(PORTALS_EVENTS.PUBLISH_ARTICLE);
       }
     }
-    await refreshArticleMeta();
+    await updateArticlesMeta();
+    await updatePortalMeta();
   } catch (error) {
-    const fallbackMessage =
-      {
-        delete: t('HELP_CENTER.DELETE_ARTICLE.API.ERROR_MESSAGE'),
-        'discard-draft': t(
-          'HELP_CENTER.EDIT_ARTICLE_PAGE.HEADER.DISCARD_CHANGES_ERROR'
-        ),
-      }[action] ?? getStatusMessage(status, false);
-    useAlert(error?.message || fallbackMessage);
+    const errorMessage =
+      error?.message ||
+      (action === 'delete'
+        ? t('HELP_CENTER.DELETE_ARTICLE.API.ERROR_MESSAGE')
+        : getStatusMessage(status, false));
+    useAlert(errorMessage);
   }
 };
 
@@ -241,15 +210,10 @@ const updateArticle = ({ action, value, id }) => {
         :views="item.views || 0"
         :updated-at="item.updatedAt"
         :is-selected="selectedArticleIds.has(item.id)"
-        :has-pending-changes="
-          item.status === ARTICLE_STATUSES.PUBLISHED && hasPendingChanges(item)
-        "
         selectable
         :show-selection-control="shouldShowSelectionControl(item.id)"
         @open-article="openArticle"
         @article-action="updateArticle"
-        @draft-resolved="onDraftResolved"
-        @draft-failed="onDraftFailed"
         @toggle-select="emit('toggleSelect', $event)"
         @hover="isHovered => handleCardHover(isHovered, item.id)"
       />

app/javascript/dashboard/components-next/HelpCenter/Pages/ArticlePage/ArticlesPage.vue

@@ -3,15 +3,10 @@ import { ref, computed, watch } from 'vue';
 import { useRouter, useRoute } from 'vue-router';
 import { useI18n } from 'vue-i18n';
 import { OnClickOutside } from '@vueuse/components';
-import { useStore, useMapGetter } from 'dashboard/composables/store.js';
+import { useMapGetter } from 'dashboard/composables/store.js';
 import { useConfig } from 'dashboard/composables/useConfig';
 import { debounce } from '@chatwoot/utils';
-import {
-  ARTICLE_TABS,
-  CATEGORY_ALL,
-  ARTICLE_STATUSES,
-} from 'dashboard/helper/portalHelper';
-import { hasPendingChanges } from 'dashboard/helper/articleDiffHelper';
+import { ARTICLE_TABS, CATEGORY_ALL } from 'dashboard/helper/portalHelper';
 import { FEATURE_FLAGS } from 'dashboard/featureFlags';
 import { useAlert } from 'dashboard/composables';
 import articlesAPI from 'dashboard/api/helpCenter/articles';
@@ -65,7 +60,6 @@ const emit = defineEmits([
 
 const router = useRouter();
 const route = useRoute();
-const store = useStore();
 const { t } = useI18n();
 
 const isSwitchingPortal = useMapGetter('portals/isSwitchingPortal');
@@ -233,46 +227,15 @@ const onBulkActionSuccess = message => {
 };
 
 const bulkUpdateStatus = async status => {
-  const selectedIds = [...selectedArticleIds.value];
-  const { portalSlug } = route.params;
-
-  const pendingIds = props.articles
-    .filter(
-      article =>
-        selectedIds.includes(article.id) &&
-        article.status === ARTICLE_STATUSES.PUBLISHED &&
-        hasPendingChanges(article)
-    )
-    .map(article => article.id);
-
-  // Publish promotes each pending draft; other status changes skip them.
-  const isPublishing = status === ARTICLE_STATUSES.PUBLISHED;
-  const draftIds = isPublishing ? pendingIds : [];
-  const skippedCount = isPublishing ? 0 : pendingIds.length;
-  const articleIds = selectedIds.filter(id => !pendingIds.includes(id));
-
-  if (!articleIds.length && !draftIds.length) {
-    useAlert(t('HELP_CENTER.ARTICLES_PAGE.BULK_ACTIONS.STATUS_SKIPPED_ALL'));
-    return;
-  }
-
   try {
-    if (articleIds.length) {
-      await articlesAPI.bulkUpdateStatus({ portalSlug, articleIds, status });
-    }
-    await Promise.all(
-      draftIds.map(articleId =>
-        store.dispatch('articles/publishDraft', { portalSlug, articleId })
-      )
-    );
+    await articlesAPI.bulkUpdateStatus({
+      portalSlug: route.params.portalSlug,
+      articleIds: [...selectedArticleIds.value],
+      status,
+    });
     onBulkActionSuccess(
       t('HELP_CENTER.ARTICLES_PAGE.BULK_ACTIONS.STATUS_SUCCESS')
     );
-    if (skippedCount) {
-      useAlert(
-        t('HELP_CENTER.ARTICLES_PAGE.BULK_ACTIONS.STATUS_SKIPPED', skippedCount)
-      );
-    }
   } catch (error) {
     useAlert(
       error?.message || t('HELP_CENTER.ARTICLES_PAGE.BULK_ACTIONS.STATUS_ERROR')

app/javascript/dashboard/components-next/HelpCenter/Pages/LocalePage/LocaleList.vue

@@ -2,7 +2,6 @@
 import { ref } from 'vue';
 import LocaleCard from 'dashboard/components-next/HelpCenter/LocaleCard/LocaleCard.vue';
 import LocaleContentDialog from 'dashboard/components-next/HelpCenter/Pages/LocalePage/LocaleContentDialog.vue';
-import PopularContentDialog from 'dashboard/components-next/HelpCenter/Pages/LocalePage/PopularContentDialog.vue';
 import { useStore } from 'dashboard/composables/store';
 import { useAlert, useTrack } from 'dashboard/composables';
 import { useUISettings } from 'dashboard/composables/useUISettings';
@@ -27,7 +26,6 @@ const route = useRoute();
 const { uiSettings, updateUISettings } = useUISettings();
 
 const contentDialogRef = ref(null);
-const popularContentDialogRef = ref(null);
 
 const isLocaleDefault = code => {
   return props.portal?.meta?.default_locale === code;
@@ -156,8 +154,6 @@ const handleAction = ({ action }, localeCode) => {
     publishLocale({ localeCode: localeCode });
   } else if (action === 'customize-content') {
     contentDialogRef.value.openForLocale(localeCode);
-  } else if (action === 'select-popular-content') {
-    popularContentDialogRef.value.openForLocale(localeCode);
   } else if (action === 'delete') {
     deletePortalLocale({ localeCode: localeCode });
   }
@@ -178,6 +174,5 @@ const handleAction = ({ action }, localeCode) => {
       @action="handleAction($event, locale.code)"
     />
     <LocaleContentDialog ref="contentDialogRef" :portal="portal" />
-    <PopularContentDialog ref="popularContentDialogRef" :portal="portal" />
   </ul>
 </template>

app/javascript/dashboard/components-next/HelpCenter/Pages/LocalePage/PopularContentDialog.vue

@@ -1,235 +0,0 @@
-<script setup>
-import { ref, computed } from 'vue';
-import { useI18n } from 'vue-i18n';
-import { useDebounceFn } from '@vueuse/core';
-import { useStore } from 'dashboard/composables/store';
-import { useAlert } from 'dashboard/composables';
-import { useAbortableRequest } from 'dashboard/composables/useAbortableRequest';
-import categoriesAPI from 'dashboard/api/helpCenter/categories';
-import articlesAPI from 'dashboard/api/helpCenter/articles';
-import Dialog from 'dashboard/components-next/dialog/Dialog.vue';
-import ReorderableMultiSelect from 'dashboard/components-next/combobox/ReorderableMultiSelect.vue';
-
-const props = defineProps({
-  portal: {
-    type: Object,
-    default: () => ({}),
-  },
-});
-
-const MAX_CATEGORIES = 3;
-const MAX_ARTICLES = 6;
-const KEY = 'HELP_CENTER.LOCALES_PAGE.POPULAR_CONTENT_DIALOG';
-
-const { t } = useI18n();
-const store = useStore();
-
-const dialogRef = ref(null);
-const activeLocale = ref('');
-// One flag per picker so each shows its skeleton until its own data loads.
-const categoriesLoading = ref(false);
-const { run: runArticleRequest, isPending: articlesLoading } =
-  useAbortableRequest();
-
-const categoryOptions = ref([]);
-const selectedCategoryIds = ref([]);
-
-// Articles are searched server-side, so cache options for selected items that
-// fall outside the current results.
-const articleResults = ref([]);
-const articleOptionById = ref({});
-const selectedArticleIds = ref([]);
-
-const popularContent = computed(
-  () => props.portal?.config?.popular_content || {}
-);
-
-const articleOptions = computed(() => {
-  const options = new Map();
-  selectedArticleIds.value.forEach(id => {
-    if (articleOptionById.value[id])
-      options.set(id, articleOptionById.value[id]);
-  });
-  articleResults.value.forEach(option => options.set(option.value, option));
-  return [...options.values()];
-});
-
-const toArticleOption = article => ({
-  value: article.id,
-  label: article.title,
-  subtitle: t(`${KEY}.ARTICLES.IN_CATEGORY`, {
-    category: article.category?.name || t(`${KEY}.ARTICLES.UNCATEGORIZED`),
-  }),
-});
-
-const fetchCategories = async localeCode => {
-  const {
-    data: { payload },
-  } = await categoriesAPI.get({
-    portalSlug: props.portal?.slug,
-    locale: localeCode,
-  });
-  return payload.map(category => ({
-    value: category.id,
-    label: category.name,
-    subtitle: t(`${KEY}.CATEGORIES.ARTICLES_COUNT`, {
-      count: category.meta?.articles_count || 0,
-    }),
-    icon: category.icon,
-    iconColor: category.icon_color,
-  }));
-};
-
-const requestArticles = async (query, signal) => {
-  const { data } = await articlesAPI.getArticles({
-    pageNumber: 1,
-    portalSlug: props.portal?.slug,
-    locale: activeLocale.value,
-    status: 'published',
-    query,
-    signal,
-  });
-  articleResults.value = data.payload.map(article => {
-    const option = toArticleOption(article);
-    articleOptionById.value[article.id] = option;
-    return option;
-  });
-};
-
-const searchArticles = (query = '') =>
-  runArticleRequest(signal => requestArticles(query, signal));
-
-const onArticleSearch = useDebounceFn(searchArticles, 300);
-
-// Resolve options for pre-selected articles that aren't in the current results.
-const cacheSelectedArticleOptions = async () => {
-  const unknownIds = selectedArticleIds.value.filter(
-    id => !articleOptionById.value[id]
-  );
-  await Promise.all(
-    unknownIds.map(async id => {
-      try {
-        const { data } = await articlesAPI.getArticle({
-          id,
-          portalSlug: props.portal?.slug,
-        });
-        articleOptionById.value[id] = toArticleOption(data.payload);
-      } catch {
-        // Deleted since it was picked; leave it for the id fallback.
-      }
-    })
-  );
-};
-
-const loadCategories = async localeCode => {
-  categoriesLoading.value = true;
-  try {
-    const options = await fetchCategories(localeCode);
-    // Reopened for another locale mid-flight; drop the stale response.
-    if (localeCode !== activeLocale.value) return;
-    categoryOptions.value = options;
-  } catch (error) {
-    useAlert(error?.message || t(`${KEY}.API.ERROR_MESSAGE`));
-  } finally {
-    if (localeCode === activeLocale.value) categoriesLoading.value = false;
-  }
-};
-
-const loadArticles = async () => {
-  try {
-    await runArticleRequest(signal =>
-      Promise.all([cacheSelectedArticleOptions(), requestArticles('', signal)])
-    );
-  } catch (error) {
-    useAlert(error?.message || t(`${KEY}.API.ERROR_MESSAGE`));
-  }
-};
-
-const openForLocale = localeCode => {
-  const existing = popularContent.value[localeCode] || {};
-  activeLocale.value = localeCode;
-  selectedCategoryIds.value = [...(existing.category_ids || [])];
-  selectedArticleIds.value = [...(existing.article_ids || [])];
-  categoryOptions.value = [];
-  articleResults.value = [];
-  articleOptionById.value = {};
-  dialogRef.value?.open();
-
-  loadCategories(localeCode);
-  loadArticles();
-};
-
-const onConfirm = async () => {
-  const updated = { ...popularContent.value };
-  const entry = {
-    category_ids: selectedCategoryIds.value,
-    article_ids: selectedArticleIds.value,
-  };
-
-  if (entry.category_ids.length || entry.article_ids.length) {
-    updated[activeLocale.value] = entry;
-  } else {
-    delete updated[activeLocale.value];
-  }
-
-  try {
-    await store.dispatch('portals/update', {
-      portalSlug: props.portal?.slug,
-      config: { popular_content: updated },
-    });
-    dialogRef.value?.close();
-    useAlert(t(`${KEY}.API.SUCCESS_MESSAGE`));
-  } catch (error) {
-    useAlert(error?.message || t(`${KEY}.API.ERROR_MESSAGE`));
-  }
-};
-
-defineExpose({ openForLocale });
-</script>
-
-<template>
-  <Dialog
-    ref="dialogRef"
-    type="edit"
-    :title="t(`${KEY}.TITLE`)"
-    :description="t(`${KEY}.DESCRIPTION`)"
-    :confirm-button-label="t(`${KEY}.CONFIRM`)"
-    @confirm="onConfirm"
-  >
-    <div class="flex flex-col gap-5">
-      <ReorderableMultiSelect
-        v-model="selectedCategoryIds"
-        :options="categoryOptions"
-        :max="MAX_CATEGORIES"
-        :label="t(`${KEY}.CATEGORIES.LABEL`)"
-        :add-label="t(`${KEY}.ADD_ANOTHER`)"
-        :search-placeholder="t(`${KEY}.SEARCH`)"
-        :empty-state="t(`${KEY}.EMPTY`)"
-        fallback-icon="i-lucide-folder"
-        :loading="categoriesLoading"
-      >
-        <template #counter="{ remaining }">
-          {{ t(`${KEY}.SLOTS_LEFT`, { count: remaining }) }}
-        </template>
-        <template #note>{{ t(`${KEY}.OVERRIDING_DEFAULTS`) }}</template>
-      </ReorderableMultiSelect>
-      <ReorderableMultiSelect
-        v-model="selectedArticleIds"
-        server-search
-        :options="articleOptions"
-        :max="MAX_ARTICLES"
-        :label="t(`${KEY}.ARTICLES.LABEL`)"
-        :add-label="t(`${KEY}.ADD_ANOTHER`)"
-        :search-placeholder="t(`${KEY}.SEARCH`)"
-        :empty-state="t(`${KEY}.EMPTY`)"
-        :loading="articlesLoading"
-        @search="onArticleSearch"
-      >
-        <template #counter="{ remaining }">
-          {{ t(`${KEY}.SLOTS_LEFT`, { count: remaining }) }}
-        </template>
-        <template #note>{{ t(`${KEY}.OVERRIDING_DEFAULTS`) }}</template>
-      </ReorderableMultiSelect>
-    </div>
-  </Dialog>
-</template>

app/javascript/dashboard/components-next/Inbox/InboxCard.vue

@@ -49,8 +49,8 @@ const isUnread = computed(() => !props.inboxItem?.readAt);
 const inbox = computed(() => props.stateInbox);
 
 const inboxIcon = computed(() => {
-  const { channelType, medium, voiceEnabled } = inbox.value;
-  return getInboxIconByType(channelType, medium, 'fill', voiceEnabled);
+  const { channelType, medium } = inbox.value;
+  return getInboxIconByType(channelType, medium);
 });
 
 const hasSlaThreshold = computed(() => {

app/javascript/dashboard/components-next/NewConversation/ComposeConversation.vue

@@ -234,7 +234,6 @@ onMounted(() => resetContacts());
     ref="popoverRef"
     :align="align"
     :show-content-border="false"
-    :close-on-scroll="false"
     @show="onPopoverShow"
     @hide="onPopoverHide"
   >

app/javascript/dashboard/components-next/NewConversation/helpers/composeConversationHelper.js

@@ -37,11 +37,10 @@ const transformInbox = ({
   channelType,
   phoneNumber,
   medium,
-  voiceEnabled,
   ...rest
 }) => ({
   id,
-  icon: getInboxIconByType(channelType, medium, 'line', voiceEnabled),
+  icon: getInboxIconByType(channelType, medium, 'line'),
   label: generateLabelForContactableInboxesList({
     name,
     email,
@@ -55,7 +54,6 @@ const transformInbox = ({
   phoneNumber,
   channelType,
   medium,
-  voiceEnabled,
   ...rest,
 });