openclacky 0.9.7 → 0.9.9

data/lib/clacky/default_skills/personal-website/publish.rb

@@ -0,0 +1,214 @@
+#!/usr/bin/env ruby
+# publish.rb — Publish or delete a profile card on the platform
+#
+# Usage:
+#   ruby publish.rb publish --name "NAME" --html-file /path/to/card.html
+#   ruby publish.rb delete  --slug SLUG
+#
+# On first publish, prints the card URL and saves the update token to
+# ~/.clacky/card_token (used for future updates/deletes).
+#
+# Environment:
+#   CARD_API_BASE   — platform base URL (default: https://app.clacky.ai)
+#   CARD_HMAC_SECRET — shared secret (default matches platform default)
+
+require "net/http"
+require "uri"
+require "json"
+require "openssl"
+require "digest"
+require "optparse"
+require "fileutils"
+
+# ── Config ───────────────────────────────────────────────────────────────────
+
+API_BASE     = ENV.fetch("CLACKY_LICENSE_SERVER", "https://www.openclacky.com")
+HMAC_SECRET  = ENV.fetch("CARD_HMAC_SECRET", "openclacky-card-v1-default-secret-change-me")
+TOKEN_FILE   = File.expand_path("~/clacky_workspace/personal_website/token.json")
+
+# ── HMAC signing ─────────────────────────────────────────────────────────────
+
+def device_fingerprint
+  # Combine stable machine identifiers into an opaque hash
+  parts = []
+  parts << `hostname`.strip
+  # macOS: hardware UUID
+  hw = `system_profiler SPHardwareDataType 2>/dev/null | grep 'Hardware UUID'`.strip
+  parts << hw unless hw.empty?
+  # Fallback: username
+  parts << ENV["USER"].to_s
+  Digest::SHA256.hexdigest(parts.join("|"))[0, 16]
+end
+
+def hmac_headers
+  ts          = Time.now.to_i.to_s
+  fingerprint = device_fingerprint
+  payload     = "openclacky:#{ts}:#{fingerprint}"
+  signature   = OpenSSL::HMAC.hexdigest("SHA256", HMAC_SECRET, payload)
+  {
+    "X-Card-Timestamp"   => ts,
+    "X-Card-Fingerprint" => fingerprint,
+    "X-Card-Signature"   => signature,
+    "Content-Type"       => "application/json"
+  }
+end
+
+# ── HTTP helpers ──────────────────────────────────────────────────────────────
+
+def http_request(method, path, body: nil)
+  uri  = URI.parse("#{API_BASE}#{path}")
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl = uri.scheme == "https"
+  http.read_timeout = 15
+  http.open_timeout = 10
+
+  req_class = { "POST" => Net::HTTP::Post, "PATCH" => Net::HTTP::Patch,
+                "DELETE" => Net::HTTP::Delete }[method]
+  req = req_class.new(uri.path)
+  hmac_headers.each { |k, v| req[k] = v }
+  req.body = body.to_json if body
+
+  response = http.request(req)
+  parsed   = JSON.parse(response.body) rescue { "raw" => response.body }
+  [response.code.to_i, parsed]
+rescue => e
+  warn "❌ Network error: #{e.message}"
+  exit 1
+end
+
+# ── Token storage ─────────────────────────────────────────────────────────────
+
+def load_token_data
+  return {} unless File.exist?(TOKEN_FILE)
+  JSON.parse(File.read(TOKEN_FILE)) rescue {}
+end
+
+def save_token_data(data)
+  FileUtils.mkdir_p(File.dirname(TOKEN_FILE))
+  File.write(TOKEN_FILE, JSON.pretty_generate(data))
+  File.chmod(0600, TOKEN_FILE)
+end
+
+# ── Commands ──────────────────────────────────────────────────────────────────
+
+def cmd_publish(name:, html_file:)
+  unless File.exist?(html_file)
+    warn "❌ HTML file not found: #{html_file}"
+    exit 1
+  end
+
+  html_content = File.read(html_file, encoding: "utf-8")
+
+  if html_content.bytesize > 1_048_576
+    warn "❌ HTML file exceeds 1MB (#{html_content.bytesize / 1024}KB)"
+    exit 1
+  end
+
+  token_data = load_token_data
+
+  # If we already have a slug + token, do an update (PATCH) instead of create
+  if token_data["slug"] && token_data["update_token"]
+    slug  = token_data["slug"]
+    token = token_data["update_token"]
+
+    uri  = URI.parse("#{API_BASE}/api/v1/personal_websites/#{slug}")
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = uri.scheme == "https"
+    req  = Net::HTTP::Patch.new(uri.path)
+    hmac_headers.each { |k, v| req[k] = v }
+    req["X-Card-Token"] = token
+    req.body = { html_content: html_content }.to_json
+    resp   = http.request(req)
+    status = resp.code.to_i
+    body   = JSON.parse(resp.body) rescue { "raw" => resp.body }
+
+    if status == 200
+      puts "✅ Website updated: #{body["url"]}"
+    else
+      warn "❌ Update failed (#{status}): #{body["error"] || body.inspect}"
+      exit 1
+    end
+  else
+    # First publish — POST to create
+    status, body = http_request("POST", "/api/v1/personal_websites",
+      body: { name: name, html_content: html_content })
+
+    if status == 201
+      save_token_data("slug" => body["slug"], "update_token" => body["update_token"])
+      puts "✅ Website published: #{body["url"]}"
+      puts "   Slug: #{body["slug"]}"
+      puts "   Token saved to: #{TOKEN_FILE}"
+    else
+      warn "❌ Publish failed (#{status}): #{body["error"] || body.inspect}"
+      exit 1
+    end
+  end
+end
+
+def cmd_delete(slug: nil)
+  token_data = load_token_data
+  token = token_data["update_token"]
+  slug  = slug || token_data["slug"]
+
+  unless token && slug
+    warn "❌ No published website found (#{TOKEN_FILE} missing or incomplete)."
+    warn "   Nothing to delete."
+    exit 1
+  end
+
+  uri  = URI.parse("#{API_BASE}/api/v1/personal_websites/#{slug}")
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl = uri.scheme == "https"
+  req  = Net::HTTP::Delete.new(uri.path)
+  hmac_headers.each { |k, v| req[k] = v }
+  req["X-Card-Token"] = token
+
+  resp   = http.request(req)
+  status = resp.code.to_i
+  body   = JSON.parse(resp.body) rescue { "raw" => resp.body }
+
+  if status == 200
+    File.delete(TOKEN_FILE) if File.exist?(TOKEN_FILE)
+    puts "✅ Personal website deleted: /~#{slug}"
+  else
+    warn "❌ Delete failed (#{status}): #{body["error"] || body.inspect}"
+    exit 1
+  end
+rescue => e
+  warn "❌ Network error: #{e.message}"
+  exit 1
+end
+
+# ── CLI parsing ───────────────────────────────────────────────────────────────
+
+command = ARGV.shift
+
+case command
+when "publish"
+  options = {}
+  OptionParser.new do |opts|
+    opts.on("--name NAME")          { |v| options[:name]      = v }
+    opts.on("--html-file FILE")     { |v| options[:html_file] = v }
+  end.parse!
+
+  unless options[:name] && options[:html_file]
+    warn "Usage: ruby publish.rb publish --name NAME --html-file FILE"
+    exit 1
+  end
+
+  cmd_publish(name: options[:name], html_file: File.expand_path(options[:html_file]))
+
+when "delete"
+  options = {}
+  OptionParser.new do |opts|
+    opts.on("--slug SLUG") { |v| options[:slug] = v }  # optional, auto-read from token file
+  end.parse!
+
+  cmd_delete(slug: options[:slug])
+
+else
+  warn "Usage: ruby publish.rb publish|delete [options]"
+  warn "  publish --name NAME --html-file FILE"
+  warn "  delete  --slug SLUG"
+  exit 1
+end

data/lib/clacky/default_skills/skill-add/SKILL.md

@@ -11,12 +11,12 @@ Installs a skill from a zip URL **or a local zip file path** using the bundled `
 
 ## How to Install
 
-The script path is available as `$SKILL_DIR/scripts/install_from_zip.rb` — use it directly, no `find` needed.
+The script path is listed in the Supporting Files above (`scripts/install_from_zip.rb`) — use the full path directly, no `find` needed.
 
 The script accepts **either a remote URL or a local file path**:
 
 ```bash
-ruby "$SKILL_DIR/scripts/install_from_zip.rb" <zip_url_or_path> [slug]
+ruby "SKILL_DIR/scripts/install_from_zip.rb" <zip_url_or_path> [slug]
 ```
 
 - `<zip_url_or_path>` — a remote `https://` URL **or** an absolute/relative local path to a `.zip` file
@@ -26,7 +26,7 @@ The script handles everything automatically:
 - For URLs: downloads the zip (follows HTTP redirects)
 - For local paths: reads the file directly (no download needed)
 - Extracts and locates all `SKILL.md` files inside
-- Copies skill directories to `.clacky/skills/` in the current project (overwrites existing)
+- Copies skill directories to `~/.clacky/skills/`
 - Reports installed skills with their descriptions
 
 **Do NOT manually download or unzip — the script handles everything.**
@@ -38,7 +38,7 @@ The script handles everything automatically:
 /skill-add https://store.clacky.ai/skills/canvas-design-1.2.0.zip
 ```
 ```bash
-ruby "$SKILL_DIR/scripts/install_from_zip.rb" \
+ruby "SKILL_DIR/scripts/install_from_zip.rb" \
   "https://store.clacky.ai/skills/canvas-design-1.2.0.zip" \
   "canvas-design"
 ```
@@ -48,13 +48,12 @@ ruby "$SKILL_DIR/scripts/install_from_zip.rb" \
 /skill-add /Users/alice/Downloads/my-skill-1.0.0.zip
 ```
 ```bash
-ruby "$SKILL_DIR/scripts/install_from_zip.rb" \
+ruby "SKILL_DIR/scripts/install_from_zip.rb" \
   "/Users/alice/Downloads/my-skill-1.0.0.zip"
 ```
 
 ## Notes
 
-- Skills install to `.clacky/skills/` in the current project
-- Project-level skills override global skills (`~/.clacky/skills/`)
+- Skills install to `~/.clacky/skills/` by default
 - Local paths may be absolute (`/path/to/skill.zip`) or use `~` (`~/Downloads/skill.zip`)
 - If the user doesn't provide a URL or path, ask them for the zip source

data/lib/clacky/default_skills/skill-add/scripts/install_from_zip.rb

@@ -26,7 +26,7 @@ class ZipSkillInstaller
     # If not provided, we try to infer it from the filename in the URL/path, e.g.
     # "ui-ux-pro-max-1.0.0.zip" → "ui-ux-pro-max".
     @skill_name = skill_name || infer_skill_name(zip_source)
-    @target_dir = target_dir || File.join(Dir.pwd, '.clacky', 'skills')
+    @target_dir = target_dir || File.join(Dir.home, '.clacky', 'skills')
     @installed_skills = []
     @errors = []
   end

data/lib/clacky/default_skills/skill-creator/SKILL.md

@@ -151,13 +151,13 @@ end
 puts result  # stdout is the output
 ```
 
-Invoke from SKILL.md using the built-in `$SKILL_DIR` variable — it expands to the skill's absolute directory path at runtime, so the script reference always works regardless of where the skill is installed (user-level, project-level, or shipped with the gem):
+Invoke from SKILL.md by referencing the script via the Supporting Files block — at runtime, the AI receives the full absolute path of every supporting file. Refer to it as `SKILL_DIR` in instructions so the AI substitutes the correct path from the Supporting Files list:
 
 ```bash
-ruby "$SKILL_DIR/scripts/do_something.rb" "argument"
+ruby "SKILL_DIR/scripts/do_something.rb" "argument"
 ```
 
-Never hardcode paths like `~/.clacky/skills/my-skill/scripts/...` — they break when the skill is installed at a different location. Never use `find` to locate scripts — `$SKILL_DIR` is always correct and requires no shell command.
+Never hardcode paths like `~/.clacky/skills/my-skill/scripts/...` — they break when the skill is installed at a different location. Never use `find` to locate scripts — the Supporting Files block always provides the correct absolute paths.
 
 Ruby standard library covers most needs (`net/http`, `json`, `fileutils`, `uri`, `time`). No gems needed for basic API calls.
 

data/lib/clacky/json_ui_controller.rb

@@ -97,6 +97,10 @@ module Clacky
       emit("info", message: message)
     end
 
+    def show_idle_status(phase:, message:)
+      emit("idle_status", phase: phase.to_s, message: message)
+    end
+
     def show_warning(message)
       emit("warning", message: message)
     end
@@ -189,5 +193,6 @@ module Clacky
     def stop
       # no-op
     end
+
   end
 end

data/lib/clacky/message_format/open_ai.rb

@@ -99,10 +99,16 @@ module Clacky
 
         response[:tool_calls].map do |tc|
           result = results_map[tc[:id]]
+          raw_content = result ? result[:content] : { error: "Tool result missing" }.to_json
+
+          # OpenAI tool message content must be a String.
+          # If a tool returned multipart Array blocks (e.g. screenshot image), convert to JSON.
+          content = raw_content.is_a?(Array) ? JSON.generate(raw_content) : raw_content
+
           {
             role:         "tool",
             tool_call_id: tc[:id],
-            content:      result ? result[:content] : { error: "Tool result missing" }.to_json
+            content:      content
           }
         end
       end

data/lib/clacky/plain_ui_controller.rb

@@ -87,6 +87,11 @@ module Clacky
       puts_line("[info] #{message}")
     end
 
+    def show_idle_status(phase:, message:)
+      # In plain mode, just print the final state
+      puts_line("[info] #{message}") if phase.to_s == "end"
+    end
+
     def show_warning(message)
       puts_line("[warn] #{message}")
     end

data/lib/clacky/server/browser_manager.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Clacky
+  # BrowserManager owns the chrome-devtools-mcp daemon lifecycle.
+  #
+  # It mirrors the ChannelManager pattern:
+  #   - start   → read browser.yml; if enabled, pre-warm the MCP daemon
+  #   - stop    → kill the daemon
+  #   - reload  → stop + re-read yml + start (called after browser-setup writes yml)
+  #   - status  → { enabled: bool, daemon_running: bool, chrome_version: String|nil }
+  #   - toggle  → flip enabled in browser.yml and reload
+  #
+  # browser.yml schema:
+  #   enabled: true/false   — whether the browser tool is active
+  #   chrome_version: "146" — detected Chrome version (set by browser-setup skill)
+  #   configured_at: date   — when setup was last run
+  #
+  # Liveness check strategy:
+  #   process_alive? sends an MCP `ping` (standard in MCP spec 2024-11-05) and
+  #   waits up to 3s for a response.  If the ping succeeds the daemon is healthy.
+  #   If it times out or raises an IO error the daemon is truly dead — kill it so
+  #   ensure_process! will spawn a fresh one on the next call.
+  #
+  #   Chrome connection problems (e.g. Chrome closed) surface only during the
+  #   actual mcp_call and are reported back to the caller; they do NOT trigger a
+  #   daemon restart.
+  #
+  # Browser tool (browser.rb) delegates daemon access here instead of using
+  # class-level @@mcp_process variables directly.  BrowserManager holds the
+  # single mutable state; the mutex lives here too.
+  class BrowserManager
+    BROWSER_CONFIG_PATH = File.expand_path("~/.clacky/browser.yml").freeze
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+    end
+
+    def initialize
+      @process = nil   # { stdin:, stdout:, pid:, wait_thr: }
+      @mutex   = Mutex.new
+      @call_id = 2     # 1 reserved for MCP initialize handshake
+      @config  = {}    # last successfully read browser.yml content
+    end
+
+    # ---------------------------------------------------------------------------
+    # Lifecycle
+    # ---------------------------------------------------------------------------
+
+    # Start the daemon if browser.yml marks the browser as enabled.
+    # Non-blocking — returns immediately (daemon spawn takes ~200ms in background).
+    def start
+      cfg = load_config
+      unless cfg["enabled"] == true
+        Clacky::Logger.info("[BrowserManager] Not enabled — skipping daemon start")
+        return
+      end
+
+      @config = cfg
+      Clacky::Logger.info("[BrowserManager] Browser enabled, pre-warming MCP daemon...")
+      Thread.new do
+        Thread.current.name = "browser-manager-start"
+        @mutex.synchronize { ensure_process! }
+      rescue StandardError => e
+        Clacky::Logger.warn("[BrowserManager] Pre-warm failed: #{e.message}")
+      end
+    end
+
+    # Stop and clean up the daemon.
+    def stop
+      @mutex.synchronize { kill_process! }
+      Clacky::Logger.info("[BrowserManager] Daemon stopped")
+    end
+
+    # Hot-reload: stop existing daemon, re-read yml, restart if enabled.
+    # Called by HttpServer after browser-setup writes a new browser.yml.
+    def reload
+      Clacky::Logger.info("[BrowserManager] Reloading...")
+      @mutex.synchronize { kill_process! }
+
+      cfg = load_config
+      @config = cfg
+
+      if cfg["enabled"] == true
+        Clacky::Logger.info("[BrowserManager] Browser enabled, restarting daemon")
+        Thread.new do
+          Thread.current.name = "browser-manager-reload"
+          @mutex.synchronize { ensure_process! }
+        rescue StandardError => e
+          Clacky::Logger.warn("[BrowserManager] Reload start failed: #{e.message}")
+        end
+      else
+        Clacky::Logger.info("[BrowserManager] Browser disabled after reload — daemon not started")
+      end
+    end
+
+    # Returns a status hash with real daemon liveness.
+    # @return [Hash] { enabled: bool, daemon_running: bool, chrome_version: String|nil }
+    def status
+      cfg     = load_config
+      enabled = cfg["enabled"] == true
+      running = @mutex.synchronize { process_alive? }
+      {
+        enabled:        enabled,
+        daemon_running: running,
+        chrome_version: cfg["chrome_version"]
+      }
+    end
+
+    # Write browser.yml with the given config and reload the daemon.
+    # Called by HttpServer POST /api/browser/configure.
+    # @param chrome_version [String] detected Chrome major version
+    def configure(chrome_version:)
+      cfg = {
+        "enabled"        => true,
+        "browser"        => "chrome",
+        "chrome_version" => chrome_version.to_s,
+        "configured_at"  => Date.today.to_s
+      }
+      FileUtils.mkdir_p(File.dirname(BROWSER_CONFIG_PATH))
+      File.write(BROWSER_CONFIG_PATH, cfg.to_yaml)
+      reload
+    end
+
+    # Toggle the browser tool on/off by flipping `enabled` in browser.yml.
+    # Raises if browser.yml doesn't exist (not yet set up).
+    # @return [Boolean] new enabled state
+    def toggle
+      raise "Browser not configured. Run /browser-setup first." unless File.exist?(BROWSER_CONFIG_PATH)
+
+      cfg         = load_config
+      new_enabled = !(cfg["enabled"] == true)
+      cfg["enabled"] = new_enabled
+      File.write(BROWSER_CONFIG_PATH, cfg.to_yaml)
+      @config = cfg
+      reload
+      new_enabled
+    end
+
+    # ---------------------------------------------------------------------------
+    # MCP call interface — used by Browser tool
+    # ---------------------------------------------------------------------------
+
+    # Execute a chrome-devtools-mcp tool call. Ensures daemon is running first.
+    # Thread-safe via @mutex.
+    # @param tool_name  [String]
+    # @param arguments  [Hash]
+    # @return [Hash] parsed MCP result
+    # @raise [RuntimeError] on timeout or protocol error
+    def mcp_call(tool_name, arguments = {})
+      call_resp = nil
+
+      @mutex.synchronize do
+        ensure_process!
+
+        call_id  = @call_id
+        @call_id += 1
+
+        msg = json_rpc("tools/call", { name: tool_name, arguments: arguments }, id: call_id)
+        @process[:stdin].write(msg + "\n")
+        @process[:stdin].flush
+
+        call_resp = read_response(@process[:stdout], target_id: call_id,
+                                  timeout: Clacky::Tools::Browser::MCP_CALL_TIMEOUT)
+
+        unless call_resp
+          kill_process!
+          raise "Chrome MCP tools/call '#{tool_name}' timed out after #{Clacky::Tools::Browser::MCP_CALL_TIMEOUT}s"
+        end
+
+        if call_resp["error"]
+          err = call_resp["error"]
+          raise "Chrome MCP error: #{err.is_a?(Hash) ? err["message"] : err}"
+        end
+
+        result = call_resp["result"] || {}
+
+        if result["isError"]
+          text = extract_text_content(result)
+          raise text.empty? ? "Chrome MCP tool '#{tool_name}' failed" : text
+        end
+
+        result
+      end
+    end
+
+    # ---------------------------------------------------------------------------
+    # Private
+    # ---------------------------------------------------------------------------
+    private
+
+    def load_config
+      return {} unless File.exist?(BROWSER_CONFIG_PATH)
+      YAML.safe_load(File.read(BROWSER_CONFIG_PATH), permitted_classes: [Date, Time, Symbol]) || {}
+    rescue StandardError => e
+      Clacky::Logger.warn("[BrowserManager] Failed to read browser.yml: #{e.message}")
+      {}
+    end
+
+    # Must be called inside @mutex
+    def ensure_process!
+      return if process_alive?
+
+      cmd = Clacky::Tools::Browser.build_mcp_command
+      stdin, stdout, stderr_io, wait_thr = Open3.popen3(*cmd)
+      Thread.new { stderr_io.read rescue nil }
+
+      # MCP handshake
+      init_msg = json_rpc("initialize", {
+        protocolVersion: "2024-11-05",
+        capabilities:    {},
+        clientInfo:      { name: "clacky", version: "1.0" }
+      }, id: 1)
+
+      notify_msg = JSON.generate({
+        jsonrpc: "2.0",
+        method:  "notifications/initialized",
+        params:  {}
+      })
+
+      stdin.write(init_msg + "\n")
+      stdin.flush
+
+      init_resp = read_response(stdout, target_id: 1,
+                                timeout: Clacky::Tools::Browser::MCP_HANDSHAKE_TIMEOUT)
+      unless init_resp
+        Process.kill("TERM", wait_thr.pid) rescue nil
+        raise "Chrome MCP initialize handshake timed out"
+      end
+
+      stdin.write(notify_msg + "\n")
+      stdin.flush
+
+      @process = { stdin: stdin, stdout: stdout, pid: wait_thr.pid, wait_thr: wait_thr }
+      @call_id = 2
+      Clacky::Logger.info("[BrowserManager] MCP daemon started (pid=#{wait_thr.pid})")
+    end
+
+    # Must be called inside @mutex.
+    # Sends an MCP `ping` (MCP spec 2024-11-05) and waits up to 3s for a pong.
+    # A successful ping means the MCP daemon process is alive and responsive.
+    # Chrome connection health is NOT checked here — Chrome problems surface only
+    # during the actual mcp_call and are reported back to the caller.
+    def process_alive?
+      return false if @process.nil?
+
+      ping_id = 0
+      msg = json_rpc("ping", {}, id: ping_id)
+      @process[:stdin].write(msg + "\n")
+      @process[:stdin].flush
+      resp = read_response(@process[:stdout], target_id: ping_id, timeout: 3)
+      if resp.nil?
+        kill_process!
+        return false
+      end
+      true
+    rescue StandardError
+      kill_process!
+      false
+    end
+
+    # Must be called inside @mutex
+    def kill_process!
+      ps = @process
+      return unless ps
+
+      Process.kill("TERM", ps[:pid]) rescue nil
+      ps[:stdin].close  rescue nil
+      ps[:stdout].close rescue nil
+      @process = nil
+      Clacky::Logger.info("[BrowserManager] MCP daemon killed")
+    end
+
+    def json_rpc(method, params, id:)
+      JSON.generate({ jsonrpc: "2.0", id: id, method: method, params: params })
+    end
+
+    def read_response(io, target_id:, timeout: 10)
+      Timeout.timeout(timeout) do
+        loop do
+          line = io.gets
+          break if line.nil?
+          line = line.strip
+          next if line.empty?
+          begin
+            msg = JSON.parse(line)
+            return msg if msg.is_a?(Hash) && msg["id"] == target_id
+          rescue JSON::ParserError
+            next
+          end
+        end
+        nil
+      end
+    rescue Timeout::Error
+      nil
+    end
+
+    def extract_text_content(result)
+      Array(result["content"])
+        .select { |b| b.is_a?(Hash) && b["type"] == "text" }
+        .map { |b| b["text"].to_s }
+        .join("\n")
+    end
+  end
+end