livechat 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8510b0623f63c828acb19577dc5383d2541a245e5cda9ee667b1dba3f3a5b19
-  data.tar.gz: 3ae2d82e86cd025e3a750bbf583e3362273bc1b4c2b5888432b45e6445c754fc
+  metadata.gz: 275ee37e54a4e5a5b30abb69aea78e691d05c78e2b6e25124bb51b10b442881e
+  data.tar.gz: 7769b4a9dfe5851ca2d7f1bece6c3c4197c9573a4be6e87673df1f40ce5be8c8
 SHA512:
-  metadata.gz: 1c6186e6fc58c2b3b9c4732e8f25dcc07e358698ac5c31ebf60cdb8d08bf27cd50ff27e3e67b5c28713c4f14fc9eb323e55620926132ab76ca08c36829dd4eb9
-  data.tar.gz: fce349af0d40f1b1fd547b6cf442d8f81acec08ff425f5e105326149fce925c6c594161a3350b924ed42e947be079257776783effa2820eb732f6ea11886f56f
+  metadata.gz: '08038c4cea2d6942c3e5270dd610385e891178018436aa6feeb4191d0f08129937087662217d56ab298f2284bfb16463a093c5e872ede78d76e8fb1ca28ccb0f'
+  data.tar.gz: f788355751c85357edb0c7e79db9b9c5c6e775efe79e30c5f6b7249fe9a1fc2ad5adb247da7a4adea70b78a13a6e917b20d723dd935c3b3a3f706db48aa7befe

data/AGENTS.md

@@ -0,0 +1,173 @@
+# AGENTS.md
+
+Instructions for coding agents. Two audiences:
+
+- **[Installing livechat into a Rails app](#installing-into-a-rails-app)** — you are working in a host app and were asked to add support chat, live chat, or an in-app inbox.
+- **[Working on the gem itself](#working-on-the-gem-itself)** — you are working in this repository.
+
+Requirements: Ruby >= 3.2, Rails >= 7.1. Active Storage only for file attachments. **No Redis and no Action Cable** — the transport is polling unless you opt in.
+
+If you are in a host app and this file is not in front of you, it ships inside the gem: `cat "$(bundle show livechat)/AGENTS.md"`.
+
+---
+
+## Installing into a Rails app
+
+### 1. Install
+
+```bash
+bundle add livechat
+bin/rails generate livechat:install
+bin/rails db:migrate
+```
+
+The generator writes `config/initializers/livechat.rb`, one migration (`livechat_conversations`, `livechat_messages`), and `mount_livechat at: "/livechat"` into `config/routes.rb`. Read the initializer it wrote — every option is documented there in comments, and it is the source of truth over any summary of it, including this file.
+
+Every `config.…` line below belongs inside the `Livechat.configure do |config|` block in that initializer. Uncomment and edit in place rather than appending a second `configure` block.
+
+### 2. Wire the three things the generator cannot
+
+**a. The widget tag.** Nothing appears until this is on the page:
+
+```erb
+<%# app/views/layouts/application.html.erb, before </body> %>
+<%= livechat_tag %>
+```
+
+The helper is injected into ActionView by the engine — no include, no import, no asset pipeline entry. It renders the launcher bubble bottom-right.
+
+**b. `authorize_agent` — do this before deploying.** The inbox at `/livechat` defaults to **development only**. It fails closed, so shipping without this is not an open inbox — it is a 403 reading "Forbidden. Set Livechat.config.authorize_agent to grant access."
+
+```ruby
+config.authorize_agent = ->(request) { request.env["warden"]&.user&.admin? }
+```
+
+**c. Visitor identity**, if the app has users. Without it every visitor is a cookie-tracked guest, and nobody in the inbox has a name.
+
+```ruby
+config.current_user  = ->(request) { request.env["warden"]&.user }
+config.visitor_label = ->(user) { user.name }        # what the inbox shows
+config.agent_label   = ->(user) { user.name }        # signed onto each reply
+```
+
+> **`current_user`, `enabled` and `authorize_agent` receive the raw `request`, not a controller.** Writing `->(request) { current_user }` is the most common mistake here — that method does not exist in this scope. Resolve the user *from the request*: Warden env, a signed cookie, `Current.user` if middleware already set it. Note the different shapes: `visitor_label` and `agent_label` receive the **user**, while `agent_display_name` receives the already-stored **label string**.
+
+Rails 8 built-in auth:
+
+```ruby
+config.current_user = lambda do |request|
+  token = request.cookies["session_token"]
+  Session.find_signed(token)&.user if token
+end
+```
+
+### 3. Verify
+
+```bash
+bin/rails routes | grep livechat     # engine mounted
+bin/rails livechat:seed_demo         # optional sample conversations, idempotent
+```
+
+Then in the running app: load any page, confirm the bubble appears bottom-right, send a message, and answer it at `/livechat`.
+
+### Opening the widget
+
+| Way | How |
+| --- | --- |
+| The launcher bubble | On by default. `config.show_launcher = false` to remove it |
+| Your own element | `<%= livechat_button %>`, or any element with `data-livechat-open` |
+| JavaScript | `window.Livechat.open()` |
+
+A visitor has **one conversation**, not a queue of tickets — writing again reopens the same thread. Signed-in visitors keep it across devices (keyed by user id); guests are tracked by cookie.
+
+### Email notifications need two settings, not one
+
+```ruby
+config.mailer_from = "support@example.com"   # required, or nothing sends
+config.agent_emails = ["team@example.com"]   # array, or a callable returning one
+```
+
+Setting `agent_emails` alone sends nothing: `mailer_from` is what switches email on (`Livechat.config.emails_enabled?` is `mailer_from.present?`). Notification is one email per unread stretch, not one per message.
+
+### Realtime is opt-in
+
+Polling is the default transport, on purpose — a host with no Action Cable works untouched. Turning on push requires the host to actually mount a cable:
+
+```ruby
+config.action_cable = true
+config.action_cable_url = "/cable"   # keep in sync with the mount in routes.rb
+```
+
+Leave it off unless the app already has Action Cable working. Polling is not a degraded mode here.
+
+### Attachments
+
+`config.attach_files` is on by default but **silently inert without Active Storage** in the host app (`rails active_storage:install`) — the widget keeps working, just without a paperclip. Caps: `max_attachments` (5), `max_attachment_size` (10 MB), `allowed_attachment_types` (nil = any). Files are served through the engine at `/livechat/attachments/:id`, gated per request — never a public blob URL. Do not build your own blob links.
+
+### Do not
+
+- **Do not copy the widget JavaScript into `app/javascript`, or add a `<script>` tag for it.** `livechat_tag` renders what is needed, and the engine serves the code with a content fingerprint. There is no build step and nothing for esbuild/importmap/Tailwind to know about.
+- **Do not build your own inbox.** Use the mounted one; `config.agent_layout = "admin/application"` renders it inside an existing admin shell.
+- **Do not add an Action Cable mount to "make chat realtime"** unless you also set `config.action_cable = true`. Polling is the default and is not broken.
+- **Do not set config outside the initializer.** `rate_limit` in particular is read when the controller class loads; assigning config per-request mutates it process-wide.
+- **Do not expose attachments by blob URL** — the engine's gated route exists so a leaked signed URL cannot hand over a customer's file.
+
+### Configuration worth knowing
+
+Everything is optional; a fresh install works with zero config. Full list with comments is in the generated initializer.
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `authorize_agent` | development only | **Who can read the inbox. Set before deploying.** |
+| `enabled` | everyone | Per-request gate for the widget and its endpoints |
+| `current_user` | `nil` | Receives the request; nil means guest-by-cookie |
+| `visitor_label`, `agent_label` | name/email/to_s | Receive the user |
+| `agent_display_name` | the label unchanged | Receives the label; return "Support team" to keep agents anonymous |
+| `app_name`, `greeting`, `reply_time_text`, `launcher_label` | localized defaults | Widget copy |
+| `avatar_url`, `accent_color` | `nil` | Header avatar (URL or callable) and brand hex |
+| `show_launcher` | `true` | `false` = open only from your own elements |
+| `mailer_from` | `nil` | **Required for any email at all** |
+| `agent_emails` | `nil` | Array or callable |
+| `attach_files` | `true` | Needs Active Storage; inert without it |
+| `storage_service` | app default | A `storage.yml` key for a dedicated bucket |
+| `max_attachments`, `max_attachment_size` | `5`, `10.megabytes` | Enforced server-side |
+| `allowed_attachment_types` | `nil` | Content-type allowlist |
+| `action_cable`, `action_cable_url` | `false`, `"/cable"` | Opt-in push |
+| `rate_limit` | `{ to: 30, within: 60 }` | Rails 7.2+; ignored on 7.1. `nil` disables |
+| `mount_path` | `"/livechat"` | Keep in sync with `mount_livechat at:` |
+| `on_visitor_message`, `on_agent_message` | no-ops | Run inline after save — Slack, Noticed, push |
+
+Turbo Drive and strict nonce-based CSP work out of the box. 26 locales ship with the gem, RTL included.
+
+### Common failure modes
+
+| Symptom | Cause |
+| --- | --- |
+| `/livechat` returns 403 "Set Livechat.config.authorize_agent to grant access" | Exactly what it says: still at the development-only default |
+| No bubble on the page | `livechat_tag` missing from the rendered layout, `config.enabled` false, or `show_launcher = false` with no opener of your own |
+| No notification emails | `mailer_from` not set — `agent_emails` alone does nothing |
+| Messages only appear on refresh | Expected: polling is the default. `config.action_cable = true` (with `/cable` mounted) for push |
+| No attachment button | Active Storage not installed, or `attach_files = false` |
+| `undefined local variable current_user` in the initializer | A gate lambda treated its argument as a controller. It is a `request` |
+
+---
+
+## Working on the gem itself
+
+```bash
+bundle exec rake test            # minitest, dummy app under test/dummy
+bundle exec rubocop              # must be clean
+BUNDLE_GEMFILE=gemfiles/rails_7.1.gemfile bundle exec rake test   # 7.1, 7.2, 8.0, 8.1 in gemfiles/
+```
+
+Layout: `app/` controllers, models, inbox views, mailer · `lib/livechat/` config, widget JS/CSS, seeds, engine, channels · `lib/generators/livechat/install/` the one generator · `config/locales/` 26 locales · `test/` minitest, `test/dummy` the host app.
+
+Conventions this codebase holds to — follow them rather than the first thing that works:
+
+- **Polling is the baseline, Action Cable is opt-in.** Nothing may require a cable to be mounted. The channel lives under `lib/` and is required only when `ActionCable` is defined, so eager-loading an app without it cannot fail.
+- **Active Storage is optional at runtime.** Attachment code checks for it rather than assuming it; an app without Active Storage gets a working widget, not an exception.
+- **The widget is plain ES5-style JS served by the engine**, no build step, no framework, config read from a JSON block so a Turbo visit re-reads the current page's settings.
+- **Visitor scoping is never by conversation id.** The widget's endpoints resolve the thread from the signed-in id or the guest cookie, so no id in a request can address someone else's conversation. Keep it that way.
+- **The dummy app pins `config.active_job.queue_adapter = :test`.** Do not remove it or let it drift back to the `:async` default. Attaching a file enqueues Active Storage's analysis job, and `:async` runs it on a background thread that checks out its own connection — writes no test transaction covers, landing in the middle of whatever runs next. That is a suite that fails order-dependently in a test which never created a row, and it is miserable to trace back.
+- Every user-facing change bumps `lib/livechat/version.rb` and adds a `CHANGELOG.md` entry that says what it costs, not only what it adds.
+- Commit messages are prose that explains the tradeoff — read `git log` before writing one.

data/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 0.8.0
+
+- **`config.agent_layout` now works on its own.** The inbox's stylesheet and
+  script were declared in the gem's layout, so replacing that layout dropped
+  both: unstyled inbox with its thread polling and keyboard submit dead. They
+  move into the views, so every layout gets them with nothing asked of the host.
+- **The dashboard stylesheet no longer claims selectors it does not own.** It
+  styled bare `*`, `body` and `a`, and its `.container`, `.card` and `.tabs` are
+  names other frameworks use too. Component rules now nest inside a
+  `.lvc-dashboard` wrapper the views render, and every custom property is
+  `--lvc-` prefixed — that collision ran both ways, so a host defining `--bg`
+  recoloured the inbox just as easily.
+- **Added `config.base_controller_class`.** Name the controller your own admin
+  inherits from and the inbox adopts its layout, helpers, authentication and
+  request context. It reparents the inbox only — the widget, visitor API and
+  attachment proxy stay on the engine's public controller, so it can never
+  demand a staff session from a visitor starting a chat. Default is unchanged.
+- **Migrations follow the host's `primary_key_type`,** including the engine's own
+  `messages -> conversations` foreign key, which has to match or a bigint column
+  ends up pointing at a uuid table. A uuid-keyed app has a uuid
+  `active_storage_attachments.record_id`, so bigint tables here could never hold
+  a message attachment: `attach` raised `NotNullViolation`.
+- **Dropped the `id: /\d+/` constraints** on the attachment and conversation
+  routes, which were what forced the tables to be bigint. Ordering already
+  disambiguates: every fixed-name route is declared first.
+- **`t.references :conversation` no longer creates its own index.**
+  `(conversation_id)` is a leftmost prefix of the `(conversation_id, id)` index
+  the migration already adds, so it answered no query the wider one could not.
+  Existing installs keep theirs until they drop it:
+  `remove_index :livechat_messages, :conversation_id`.
+- A `BackboneTest` now fails the build on any of the above regressing.
+
+## 0.7.2
+
+- Adds `AGENTS.md`: install and integration instructions written for coding
+  agents — the request-shaped config lambdas, the two settings email needs, why
+  polling is the default and Action Cable is opt-in, and the mistakes agents
+  actually make. It ships inside the gem, so
+  `cat "$(bundle show livechat)/AGENTS.md"` works from a host app.
+- The dummy app pins `queue_adapter = :test` for the test suite. Attaching a
+  file enqueues Active Storage's analysis job, and the default `:async` adapter
+  runs it on a background thread with its own database connection — writes no
+  test transaction covers, which is how a suite starts failing order-dependently
+  in a test that never created a row. No effect on the gem itself.
+
 ## 0.7.1
 
 - Removed the translucent border and background from the customer-facing

data/README.md

@@ -52,6 +52,11 @@ demo messages instead of duplicating conversations.
 
 Ruby >= 3.2 · Rails >= 7.1 · Active Storage only if you want file attachments.
 
+Installing with a coding agent? Point it at [AGENTS.md](AGENTS.md) — the same
+steps in the order an agent needs them, plus the gates it tends to get wrong and
+the things it should not do. It ships inside the gem, so
+`cat "$(bundle show livechat)/AGENTS.md"` works from any app that bundles it.
+
 ## What you get
 
 |               |                                                                          |
@@ -121,6 +126,7 @@ Everything is optional — a fresh install works with zero config. In
 | Option | Default | What it does |
 | --- | --- | --- |
 | `authorize_agent` | development only | **Who can read the inbox.** Override before deploying |
+| `base_controller_class` | `ActionController::Base` | Controller the inbox inherits — name your admin's and it adopts its layout, helpers and auth |
 | `enabled` | everyone | Who sees the widget. `false` hides it and rejects posts |
 | `current_user` | `nil` | Identify the visitor. Receives the request |
 | `app_name` | Rails app name | Shown in the widget header |

data/app/controllers/concerns/livechat/request_context.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Livechat
+  # Who is asking — visitor or agent — and the gates that answer it.
+  #
+  # A concern rather than inherited behaviour because the engine has two
+  # controller roots: the widget's endpoints hang off ActionController::Base, and
+  # the inbox hangs off whatever the host set as `base_controller_class`.
+  module RequestContext
+    extend ActiveSupport::Concern
+
+    private
+
+    def livechat_agent_layout
+      Livechat.config.agent_layout
+    end
+
+    def current_visitor
+      return @current_visitor if defined?(@current_visitor)
+
+      @current_visitor = Livechat.config.current_user.call(request)
+    end
+
+    def current_visitor_id
+      current_visitor.respond_to?(:id) ? current_visitor.id.to_s : nil
+    end
+
+    def require_enabled
+      head :forbidden unless Livechat.enabled?(request)
+    end
+
+    # Server-side gate for the inbox. Default: development only.
+    def require_agent
+      return if Livechat.agent?(request)
+
+      render plain: 'Forbidden. Set Livechat.config.authorize_agent to grant access.',
+             status: :forbidden
+    end
+
+    # Replies are attributed to whoever config.current_user resolves. When an
+    # inbox is protected by something user-less (HTTP basic, a VPN), replies
+    # still work — anonymously, as "Support".
+    def current_agent_id
+      current_visitor_id || '0'
+    end
+
+    def current_agent_label
+      label = (Livechat.config.agent_label.call(current_visitor).presence if current_visitor)
+      label || I18n.t(:team, scope: :livechat, default: 'Support')
+    end
+
+    def render_rate_limited
+      message = I18n.t('livechat.error_rate_limited',
+                       default: 'Too many messages. Please wait a moment and try again.')
+      render json: { errors: [message] }, status: :too_many_requests
+    end
+
+    # Guests get a permanent random token — their key to the conversation
+    # across visits. Signed-in visitors are keyed by id and only need the
+    # cookie to carry a guest history into their account.
+    def visitor_token
+      cookies[:livechat_vid]
+    end
+
+    def ensure_visitor_token
+      visitor_token.presence || begin
+        token = SecureRandom.base58(24)
+        cookies.permanent[:livechat_vid] = { value: token, httponly: true, same_site: :lax }
+        token
+      end
+    end
+
+    # A guest who signed in keeps their thread: adopt cookie-token
+    # conversations into the account, then the cookie no longer matters.
+    def claim_guest_conversations
+      return unless current_visitor_id && visitor_token
+
+      Conversation.claim!(
+        visitor_token: visitor_token,
+        visitor_id: current_visitor_id,
+        visitor_label: Livechat.config.visitor_label.call(current_visitor).presence
+      )
+    end
+  end
+end

data/app/controllers/livechat/application_controller.rb

@@ -1,80 +1,17 @@
 # frozen_string_literal: true
 
 module Livechat
+  # Root of the engine's PUBLIC surface: widget.js, the visitor API and the
+  # attachment proxy (which serves visitors as well as agents). These stay on a
+  # plain ActionController::Base deliberately — a visitor starting a chat must
+  # not be routed through a host's admin controller, which would demand a staff
+  # session for the widget.
+  #
+  # The inbox's root is DashboardController, and that is where
+  # `config.base_controller_class` applies.
   class ApplicationController < ActionController::Base
-    protect_from_forgery with: :exception
-
-    private
-
-    def livechat_agent_layout
-      Livechat.config.agent_layout
-    end
-
-    def current_visitor
-      return @current_visitor if defined?(@current_visitor)
-
-      @current_visitor = Livechat.config.current_user.call(request)
-    end
-
-    def current_visitor_id
-      current_visitor.respond_to?(:id) ? current_visitor.id.to_s : nil
-    end
-
-    def require_enabled
-      head :forbidden unless Livechat.enabled?(request)
-    end
-
-    # Server-side gate for the inbox. Default: development only.
-    def require_agent
-      return if Livechat.agent?(request)
+    include RequestContext
 
-      render plain: 'Forbidden. Set Livechat.config.authorize_agent to grant access.',
-             status: :forbidden
-    end
-
-    # Replies are attributed to whoever config.current_user resolves. When an
-    # inbox is protected by something user-less (HTTP basic, a VPN), replies
-    # still work — anonymously, as "Support".
-    def current_agent_id
-      current_visitor_id || '0'
-    end
-
-    def current_agent_label
-      label = (Livechat.config.agent_label.call(current_visitor).presence if current_visitor)
-      label || I18n.t(:team, scope: :livechat, default: 'Support')
-    end
-
-    def render_rate_limited
-      message = I18n.t('livechat.error_rate_limited',
-                       default: 'Too many messages. Please wait a moment and try again.')
-      render json: { errors: [message] }, status: :too_many_requests
-    end
-
-    # Guests get a permanent random token — their key to the conversation
-    # across visits. Signed-in visitors are keyed by id and only need the
-    # cookie to carry a guest history into their account.
-    def visitor_token
-      cookies[:livechat_vid]
-    end
-
-    def ensure_visitor_token
-      visitor_token.presence || begin
-        token = SecureRandom.base58(24)
-        cookies.permanent[:livechat_vid] = { value: token, httponly: true, same_site: :lax }
-        token
-      end
-    end
-
-    # A guest who signed in keeps their thread: adopt cookie-token
-    # conversations into the account, then the cookie no longer matters.
-    def claim_guest_conversations
-      return unless current_visitor_id && visitor_token
-
-      Conversation.claim!(
-        visitor_token: visitor_token,
-        visitor_id: current_visitor_id,
-        visitor_label: Livechat.config.visitor_label.call(current_visitor).presence
-      )
-    end
+    protect_from_forgery with: :exception
   end
 end

data/app/controllers/livechat/conversations_controller.rb

@@ -4,10 +4,8 @@ module Livechat
   # The inbox. Every action is gated by config.authorize_agent; any
   # authorized teammate can read and answer any thread — it's a shared line,
   # not an assignment queue.
-  class ConversationsController < ApplicationController
-    before_action :require_agent
+  class ConversationsController < DashboardController
     before_action :set_conversation, except: %i[index index_poll]
-    layout :livechat_agent_layout
 
     PER_PAGE = 50
 

data/app/controllers/livechat/dashboard_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Livechat
+  # Root of the AGENT surface: the inbox and agent replies.
+  #
+  # Inherits from `config.base_controller_class` — by default a plain
+  # ActionController::Base, which is why `authorize_agent` exists. Point it at
+  # the controller your own admin already inherits from and the inbox picks up
+  # that stack wholesale: your layout, your helpers, your authentication, and
+  # whatever request context your before_actions establish.
+  #
+  # Only the inbox hangs off it. The widget's endpoints stay on
+  # ApplicationController, so wiring an admin base controller here can never
+  # demand a staff session from a visitor starting a chat.
+  class DashboardController < Livechat.base_controller
+    include RequestContext
+
+    # A host base controller brings its own layout, and declaring one here would
+    # override it. So the gem only claims the layout when it owns the decision:
+    # no host base controller, or a host that named an `agent_layout` explicitly.
+    layout :livechat_agent_layout unless superclass != ActionController::Base &&
+                                         Livechat.config.agent_layout == Configuration::DEFAULT_AGENT_LAYOUT
+
+    before_action :require_agent
+
+    # A host base controller has configured CSRF already; declaring it twice
+    # would run the check twice.
+    protect_from_forgery with: :exception if superclass == ActionController::Base
+  end
+end

data/app/controllers/livechat/messages_controller.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 module Livechat
-  class MessagesController < ApplicationController
-    before_action :require_agent
-
+  class MessagesController < DashboardController
     def create
       conversation = Conversation.find(params[:conversation_id])
       message = conversation.post_agent_message!(

data/app/views/layouts/livechat/application.html.erb

@@ -5,19 +5,18 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <%= csrf_meta_tags %>
   <%= csp_meta_tag %>
-  <%= stylesheet_link_tag "#{dashboard_stylesheet_path}?v=#{Livechat::Widget.dashboard_stylesheet_fingerprint}",
-                          'data-turbo-track': 'reload' %>
-  <%# Same-origin script instead of inline handlers, so thread polling and
-      keyboard submit work under strict script-src CSPs. %>
-  <%= javascript_include_tag "#{dashboard_script_path}?v=#{Livechat::Widget.dashboard_fingerprint}",
-                             defer: true, nonce: true %>
+  <%# The inbox's stylesheet and script are declared by the views
+      (livechat/shared/_dashboard), not here, so they survive a host replacing
+      this layout via config.agent_layout or config.base_controller_class. %>
 </head>
-<body class="<%= yield(:body_class) %>">
-  <div class="container">
-    <% if flash[:alert].present? %>
-      <p class="flash alert"><%= flash[:alert] %></p>
-    <% end %>
-    <%= yield %>
+<body class="lvc-page <%= yield(:body_class) %>">
+  <div class="lvc-dashboard">
+    <div class="container">
+      <% if flash[:alert].present? %>
+        <p class="flash alert"><%= flash[:alert] %></p>
+      <% end %>
+      <%= yield %>
+    </div>
   </div>
 </body>
 </html>