openclacky 0.9.21 → 0.9.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d48d1b62badf0b608e9f6dc6cacb6b0d2c8f92263a8df77d64f6c63ee26e3580
-  data.tar.gz: f4abb3c3aa7dc140a91622135c4eaff7dfbad66bca6908abfb3c76ab7c183629
+  metadata.gz: 636621284dfcd7f7329f793bc80f2364f16a2777dedacd2fdf310b2a7f3be58a
+  data.tar.gz: 5f3a12e563e36445d3aa32ae050f5b759b204325323cac119b8692bea7d3657b
 SHA512:
-  metadata.gz: acfdcca20845b40c076f1974dde40d5d62f194af03c14541a98c02c5fd431790df3e811ac17a0d35276938bb5475a53c3e22e8c8b9f56b87d0637f7a5168d7c5
-  data.tar.gz: a3ea45c455a7591917801963bb4a08587ea1ab24173d42cb8d1d2718dbf0a17fdf40e11296840dc107863d98e4aa1a2dad8008542b6214a10bda9d575fec7715
+  metadata.gz: 23e59f8ae883ded129b4fee900c0ffdf6cec3ada4bd019e9a0243a3942abc70f5bbc8b9cc4830a34d7e66e22e4c663988295eed972ad1df63247c6f0bdbf1a68
+  data.tar.gz: 218bd984151af6f087c6ac44f3aa213e19ee30981a1a69484344cdbd00774611465fc3847ecfc0933243e2ae6277792116d96d0aed04b9148a9cfed14f09e14e

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.22] - 2026-03-31
+
+### Added
+- **ClackyAI provider (Bedrock with prompt caching)**: added `clackyai` as a first-class provider — uses AWS Bedrock under the hood with prompt caching enabled, normalising token usage to Anthropic semantics so cost calculation works correctly
+- **Browser auto-install script**: `browser-setup` skill can now detect the Chrome/Edge version and automatically download and run the install script, reducing manual setup steps
+
+### Fixed
+- **Feishu setup timeout**: `navigate` method was using `open` (new tab) instead of `navigate` (current tab), causing intermittent timeouts on macOS when opening feishu.cn
+- **Cron task schedule YAML format**: fixed a YAML serialisation bug in the scheduler that produced invalid schedule files
+
 ## [0.9.21] - 2026-03-30
 
 ### Fixed

data/lib/clacky/agent.rb

@@ -102,6 +102,9 @@ module Clacky
 
       # Ensure user-space parsers are in place (~/.clacky/parsers/)
       Utils::ParserManager.setup!
+
+      # Ensure bundled shell scripts are in place (~/.clacky/scripts/)
+      Utils::ScriptsManager.setup!
     end
 
     # Restore from a saved session

data/lib/clacky/client.rb

@@ -88,7 +88,7 @@ module Clacky
       cloned = deep_clone(messages)
 
       if bedrock?
-        send_bedrock_request(cloned, model, tools, max_tokens)
+        send_bedrock_request(cloned, model, tools, max_tokens, caching_enabled)
       elsif anthropic_format?
         send_anthropic_request(cloned, model, tools, max_tokens, caching_enabled)
       else
@@ -124,8 +124,8 @@ module Clacky
 
     # ── Bedrock Converse request / response ───────────────────────────────────
 
-    def send_bedrock_request(messages, model, tools, max_tokens)
-      body     = MessageFormat::Bedrock.build_request_body(messages, model, tools, max_tokens)
+    def send_bedrock_request(messages, model, tools, max_tokens, caching_enabled)
+      body     = MessageFormat::Bedrock.build_request_body(messages, model, tools, max_tokens, caching_enabled)
       response = bedrock_connection.post(bedrock_endpoint(model)) { |r| r.body = body.to_json }
 
       raise_error(response) unless response.status == 200

data/lib/clacky/default_skills/browser-setup/SKILL.md

@@ -1,8 +1,9 @@
 ---
 name: browser-setup
 description: |
-  Configure the browser tool for Clacky. Guides the user through Chrome setup,
+  Configure the browser tool for Clacky. Guides the user through Chrome or Edge setup,
   verifies the connection, and writes ~/.clacky/browser.yml.
+  Supports macOS, Linux, and WSL (Windows Chrome/Edge via remote debugging).
   Trigger on: "browser setup", "setup browser", "配置浏览器", "browser config",
   "browser doctor".
   Subcommands: setup, doctor.
@@ -31,45 +32,43 @@ If no subcommand is clear, default to `setup`.
 
 ## `setup`
 
-### Step 1 — Check Node.js & install chrome-devtools-mcp
+### Step 1 — Ensure chrome-devtools-mcp is installed
 
-Run:
+Check if already installed:
 ```bash
-node --version
+chrome-devtools-mcp --version 2>/dev/null
 ```
 
-If Node.js is missing or version < 20, tell the user and stop:
+If found and exits 0 → skip to Step 2.
 
-> ❌ The browser tool requires Node.js 20+.
-> Please install it first: https://nodejs.org/
-> Let me know when done and I'll retry.
-
-Then install/update `chrome-devtools-mcp`:
+If missing, run the bundled installer (handles Node.js + chrome-devtools-mcp + CN/global mirrors automatically):
 ```bash
-npm install -g chrome-devtools-mcp@latest
+bash ~/.clacky/scripts/install_browser.sh
 ```
 
-If this fails, stop and tell the user:
+If the script exits non-zero or `~/.clacky/scripts/install_browser.sh` doesn't exist, stop and tell the user:
 
-> ❌ Failed to install chrome-devtools-mcp. Please run manually:
+> ❌ Failed to install chrome-devtools-mcp automatically.
+> Please run manually:
 > ```
 > npm install -g chrome-devtools-mcp@latest
 > ```
+> (Requires Node.js 20+. If Node.js is missing, install it first, then retry.)
 > Let me know when done.
 
-### Step 2 — Try to connect to Chrome
+### Step 2 — Try to connect to the browser
 
 Immediately attempt to connect — do **not** ask the user anything first:
 
 ```
-browser(action="act", kind="evaluate", js="navigator.userAgentData?.brands?.find(b => b.brand === 'Google Chrome')?.version || navigator.userAgent.match(/Chrome\\/([\\d]+)/)?.[1] || 'unknown'")
+browser(action="act", kind="evaluate", js="navigator.userAgentData?.brands?.find(b => b.brand === 'Google Chrome' || b.brand === 'Microsoft Edge')?.version || navigator.userAgent.match(/Chrome\/([\d]+)/)?.[1] || 'unknown'")
 ```
 
-**If connection succeeds** → parse the Chrome version and jump to Step 3.
+**If connection succeeds** → parse the browser version and jump to Step 3.
 
 **If connection fails** → inspect the error message from the evaluate result to diagnose:
 
-**Case A — error contains `"timed out"`**: The MCP daemon failed to start — Chrome is not running or remote debugging is not enabled. Try to open the page for the user:
+**Case A — error contains `"timed out"`**: The MCP daemon failed to start — Chrome or Edge is not running or remote debugging is not enabled. Try to open the page for the user:
 
 ```bash
 open "chrome://inspect/#remote-debugging"
@@ -77,35 +76,38 @@ open "chrome://inspect/#remote-debugging"
 
 Tell the user:
 
-> I've opened `chrome://inspect/#remote-debugging` in Chrome.
+> I've opened `chrome://inspect/#remote-debugging` in your browser.
 > Please click **"Allow remote debugging for this browser instance"** and let me know when done.
 
-If `open` fails, fall back to:
+If `open` fails (e.g. on WSL or Linux), fall back to:
 
-> Please open this URL in Chrome:
+> Please open this URL in Chrome or Edge:
 > `chrome://inspect/#remote-debugging`
 > Then click **"Allow remote debugging for this browser instance"** and let me know when done.
+>
+> On WSL: launch your browser from PowerShell with remote debugging enabled:
+> - Edge: `Start-Process msedge --ArgumentList "--remote-debugging-port=9222"`
+> - Chrome: `Start-Process chrome --ArgumentList "--remote-debugging-port=9222"`
 
 Wait for the user to confirm, then retry the connection once. If still failing, stop:
 
-> ❌ Could not connect to Chrome. Please make sure Chrome is open and remote debugging is enabled, then run `/browser-setup` again.
+> ❌ Could not connect to the browser. Please make sure Chrome or Edge is open and remote debugging is enabled, then run `/browser-setup` again.
 
-**Case B — error contains `"Chrome MCP error:"`**: The MCP daemon is alive but Chrome's CDP connection is broken — this is a known Chrome issue after long sessions. Tell the user:
+**Case B — error contains `"Chrome MCP error:"`**: The MCP daemon is alive but the browser's CDP connection is broken — this is a known issue after long sessions. Tell the user:
 
-> Chrome's remote debugging connection is unstable.
-> Please restart Chrome and let me know when done.
+> The browser's remote debugging connection is unstable.
+> Please restart your browser and let me know when done.
 
 Wait for the user to confirm, then retry once. If still failing, stop with the same error message as Case A.
 
-### Step 3 — Check Chrome version
+### Step 3 — Check browser version
 
-Parse the version number from Step 2:
+Parse the version number from Step 2 (works for both Chrome and Edge, both are Chromium-based):
 - version >= 146 → proceed
 - version 144–145 → warn but proceed:
-  > ⚠️ Your Chrome version is vXXX. Version 146+ is recommended. Continuing anyway...
+  > ⚠️ Your browser version is vXXX. Version 146+ is recommended. Continuing anyway...
 - version < 144 or unknown → stop:
-  > ❌ Chrome vXXX is too old. Please upgrade to Chrome 146+: https://www.google.com/chrome/
-  > Let me know when you've upgraded and I'll retry.
+  > ❌ Browser vXXX is too old. Please upgrade Chrome or Edge to v146+, then let me know and I'll retry.
 
 ### Step 4 — Save config and start daemon
 
@@ -122,7 +124,7 @@ If this fails (server not running), skip silently — the daemon will start lazi
 
 > ✅ Browser configured.
 >
-> Chrome v<VERSION> is connected and ready to use.
+> Chrome/Edge v<VERSION> is connected and ready to use.
 
 ---
 

data/lib/clacky/default_skills/channel-setup/feishu_setup.rb

@@ -125,7 +125,7 @@ class BrowserSession
   end
 
   def navigate(url)
-    @client.call("open", url: url)
+    @client.call("navigate", url: url)
     sleep 2
     snapshot
   end

data/lib/clacky/default_skills/product-help/SKILL.md

@@ -53,6 +53,7 @@ Answer the user's question using the official documentation below. Always fetch
 | Built-in skills, default skills, what skills ship with OpenClacky | https://www.openclacky.com/docs/built-in-skills |
 | Memory system, long-term memory, ~/.clacky/memories | https://www.openclacky.com/docs/memory-system |
 | Session management, conversation history, context window | https://www.openclacky.com/docs/session-management |
+| Browser automation, browser tool, Chrome, Edge, CDP, remote debugging, WSL browser, browser-setup skill | https://www.openclacky.com/docs/browser-tool |
 
 ## Workflow
 

data/lib/clacky/message_format/bedrock.rb

@@ -32,13 +32,21 @@ module Clacky
       # @param max_tokens [Integer]
       # @param caching_enabled [Boolean] (currently unused for Bedrock)
       # @return [Hash] ready to serialize as JSON body
-      def build_request_body(messages, model, tools, max_tokens, _caching_enabled = false)
+      def build_request_body(messages, model, tools, max_tokens, caching_enabled = false)
         system_messages = messages.select { |m| m[:role] == "system" }
         regular_messages = messages.reject { |m| m[:role] == "system" }
 
         # Merge consecutive same-role messages (Bedrock requires alternating roles)
         api_messages = merge_consecutive_tool_results(regular_messages.map { |msg| to_api_message(msg) })
 
+        # Inject cachePoint blocks AFTER conversion to Bedrock API format.
+        # Doing this on canonical messages (before to_api_message) is incorrect because
+        # tool-result messages (role: "tool") are converted to toolResult blocks, and
+        # Bedrock does not support cachePoint inside toolResult.content.
+        # Operating on the final Bedrock format ensures cachePoint is always a top-level
+        # sibling block in the message's content array, which is what Bedrock expects.
+        api_messages = apply_api_caching(api_messages) if caching_enabled
+
         body = { messages: api_messages }
 
         # Add system prompt if present
@@ -86,11 +94,24 @@ module Clacky
                         else data["stopReason"]
                         end
 
+        cache_read  = usage["cacheReadInputTokens"].to_i
+        cache_write = usage["cacheWriteInputTokens"].to_i
+
+        # Bedrock `inputTokens` = non-cached input only.
+        # Anthropic direct `input_tokens` = all input including cache_read.
+        # Normalise to Anthropic semantics so ModelPricing.calculate_cost works correctly:
+        #   prompt_tokens = inputTokens + cacheReadInputTokens
+        # (calculate_cost subtracts cache_read_tokens from prompt_tokens to get
+        #  the billable non-cached portion; that arithmetic requires the Anthropic convention.)
+        prompt_tokens = usage["inputTokens"].to_i + cache_read
+
         usage_data = {
-          prompt_tokens:     usage["inputTokens"].to_i,
+          prompt_tokens:     prompt_tokens,
           completion_tokens: usage["outputTokens"].to_i,
           total_tokens:      usage["totalTokens"].to_i
         }
+        usage_data[:cache_read_input_tokens]     = cache_read  if cache_read  > 0
+        usage_data[:cache_creation_input_tokens] = cache_write if cache_write > 0
 
         { content: content, tool_calls: tool_calls, finish_reason: finish_reason,
           usage: usage_data, raw_api_usage: usage }
@@ -185,6 +206,8 @@ module Clacky
         when "image"
           block # already Bedrock format
         else
+          # Pass through Bedrock-native blocks (e.g. cachePoint) unchanged
+          return block if block[:cachePoint]
           # Fallback: try to extract text
           { text: (block[:text] || block.to_s) }
         end
@@ -252,6 +275,38 @@ module Clacky
         end
         merged
       end
+
+      # Inject cachePoint blocks into already-converted Bedrock API format messages.
+      # Marks the last 2 messages (from the tail) so Bedrock can cache the conversation
+      # prefix up to those points.
+      #
+      # Why operate on Bedrock API format (not canonical):
+      #   - tool-result canonical messages (role: "tool") become toolResult blocks inside
+      #     a user message. Bedrock does NOT allow cachePoint inside toolResult.content.
+      #   - After merge_consecutive_tool_results, message boundaries may differ from canonical.
+      #   - Operating here guarantees cachePoint is always a top-level sibling block.
+      private_class_method def self.apply_api_caching(api_messages)
+        return api_messages if api_messages.empty?
+
+        candidate_indices = []
+        (api_messages.length - 1).downto(0) do |i|
+          break if candidate_indices.length >= 2
+          candidate_indices << i
+        end
+
+        api_messages.map.with_index do |msg, idx|
+          next msg unless candidate_indices.include?(idx)
+
+          content = msg[:content]
+          next msg unless content.is_a?(Array)
+
+          # Don't double-add cachePoint if already present
+          already_marked = content.last.is_a?(Hash) && content.last[:cachePoint]
+          next msg if already_marked
+
+          msg.merge(content: content + [{ cachePoint: { type: "default" } }])
+        end
+      end
     end
   end
 end

data/lib/clacky/providers.rb

@@ -48,16 +48,16 @@ module Clacky
         "website_url" => "https://console.anthropic.com/settings/keys"
       }.freeze,
 
-      "bedrock-jp" => {
-        "name" => "AWS Bedrock (JP)",
-        "base_url" => "https://bedrock-runtime.ap-northeast-1.amazonaws.com",
+      "clackyai" => {
+        "name" => "Clacky AI",
+        "base_url" => "https://api.clacky.ai",
         "api" => "bedrock",
         "default_model" => "jp.anthropic.claude-sonnet-4-6",
         "models" => [
           "jp.anthropic.claude-sonnet-4-6",
           "jp.anthropic.claude-haiku-4-6"
         ],
-        "website_url" => "https://console.aws.amazon.com/iam/home#/security_credentials"
+        "website_url" => "https://clacky.ai"
       }.freeze
 
     }.freeze

data/lib/clacky/server/scheduler.rb

@@ -300,7 +300,8 @@ module Clacky
         return [] unless File.exist?(SCHEDULES_FILE)
 
         data = YAMLCompat.load_file(SCHEDULES_FILE, permitted_classes: [Symbol])
-        Array(data)
+        raw  = data.is_a?(Hash) ? data["schedules"] : data
+        Array(raw).select { |s| s.is_a?(Hash) }
       rescue => e
         Clacky::Logger.error("scheduler_load_schedules_error", error: e)
         []

data/lib/clacky/tools/browser.rb

@@ -542,9 +542,33 @@ module Clacky
       end
 
       def self.build_mcp_command(user_data_dir: nil)
-        args = CHROME_MCP_BASE_ARGS.dup
-        args += ["--userDataDir", user_data_dir.to_s] if user_data_dir && !user_data_dir.to_s.empty?
-        ["chrome-devtools-mcp", *args]
+        # If an explicit user_data_dir is given, use it directly (e.g. from browser.yml).
+        if user_data_dir && !user_data_dir.to_s.empty?
+          return ["chrome-devtools-mcp", *CHROME_MCP_BASE_ARGS, "--userDataDir", user_data_dir.to_s]
+        end
+
+        # On non-macOS/Linux platforms (especially WSL), chrome-devtools-mcp's built-in
+        # --autoConnect only scans Linux-side paths and misses Windows-side Chrome/Edge.
+        # Use BrowserDetector to find any running debuggable browser across all platforms.
+        detected = Clacky::Utils::BrowserDetector.detect
+
+        args = base_args_without_autoconnect
+        case detected&.fetch(:mode)
+        when :ws_endpoint
+          # DevToolsActivePort found — use exact WS endpoint (most reliable)
+          ["chrome-devtools-mcp", *args, "--wsEndpoint", detected[:value]]
+        when :browser_url
+          # TCP port reachable — let chrome-devtools-mcp handle WS negotiation
+          ["chrome-devtools-mcp", *args, "--browserUrl", detected[:value]]
+        else
+          # Nothing detected — fall back to --autoConnect (works on plain macOS/Linux)
+          ["chrome-devtools-mcp", *CHROME_MCP_BASE_ARGS]
+        end
+      end
+
+      # Base args without --autoConnect, used when we supply explicit connection info.
+      def self.base_args_without_autoconnect
+        CHROME_MCP_BASE_ARGS.reject { |a| a == "--autoConnect" }
       end
 
       # Delegate to BrowserManager. Auto-retries once on "selected page has been closed".

data/lib/clacky/utils/browser_detector.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Clacky
+  module Utils
+    # Detects a running browser (Chrome/Edge) that has remote debugging enabled.
+    #
+    # Detection strategy (in priority order):
+    #
+    #   1. Scan known UserData directories for DevToolsActivePort file.
+    #      This file contains the exact port + WS path — most reliable.
+    #      Returns { mode: :ws_endpoint, value: "ws://127.0.0.1:PORT/PATH" }
+    #
+    #   2. TCP port scan on common remote debugging ports (9222–9224).
+    #      Chrome 146+ dropped HTTP /json/version, so we just probe TCP connectivity
+    #      and hand off to chrome-devtools-mcp via --browserUrl.
+    #      Returns { mode: :browser_url, value: "http://127.0.0.1:PORT" }
+    #
+    #   3. Nothing found → returns nil (caller should show guidance to user).
+    #
+    # Supported environments: WSL, Linux, macOS.
+    module BrowserDetector
+      # Ports to probe when DevToolsActivePort file is not found.
+      TCP_PROBE_PORTS = [9222, 9223, 9224].freeze
+      TCP_PROBE_TIMEOUT = 0.5 # seconds
+
+      # Detect a running debuggable browser.
+      # @return [Hash, nil] { mode: :ws_endpoint|:browser_url, value: String } or nil
+      def self.detect
+        result = detect_via_active_port_file
+        result ||= detect_via_tcp_probe
+        result
+      end
+
+      # -----------------------------------------------------------------------
+      # Strategy 1: DevToolsActivePort file scan
+      # -----------------------------------------------------------------------
+
+      # @return [Hash, nil]
+      def self.detect_via_active_port_file
+        user_data_dirs.each do |dir|
+          port_file = File.join(dir, "DevToolsActivePort")
+          next unless File.exist?(port_file)
+
+          ws = parse_active_port_file(port_file)
+          return { mode: :ws_endpoint, value: ws } if ws
+        end
+        nil
+      end
+
+      # @return [Hash, nil]
+      def self.detect_via_tcp_probe
+        TCP_PROBE_PORTS.each do |port|
+          return { mode: :browser_url, value: "http://127.0.0.1:#{port}" } if tcp_open?("127.0.0.1", port)
+        end
+        nil
+      end
+
+      # -----------------------------------------------------------------------
+      # UserData directory candidates per OS
+      # -----------------------------------------------------------------------
+
+      # Returns ordered list of candidate UserData dirs to check.
+      # @return [Array<String>]
+      def self.user_data_dirs
+        case EnvironmentDetector.os_type
+        when :wsl   then wsl_user_data_dirs
+        when :linux then linux_user_data_dirs
+        when :macos then macos_user_data_dirs
+        else []
+        end
+      end
+
+      # WSL: Chrome/Edge run on Windows side — resolve via LOCALAPPDATA.
+      private_class_method def self.wsl_user_data_dirs
+        appdata = Utils::Encoding.cmd_to_utf8(
+          `powershell.exe -NoProfile -Command '$env:LOCALAPPDATA' 2>/dev/null`
+        ).strip.tr("\r\n", "")
+        return [] if appdata.empty?
+
+        win_paths = [
+          "#{appdata}\\Microsoft\\Edge\\User Data",
+          "#{appdata}\\Google\\Chrome\\User Data",
+          "#{appdata}\\Google\\Chrome Beta\\User Data",
+          "#{appdata}\\Google\\Chrome SxS\\User Data",
+        ]
+
+        win_paths.filter_map do |win_path|
+          linux_path = Utils::Encoding.cmd_to_utf8(
+            `wslpath '#{win_path}' 2>/dev/null`, source_encoding: "UTF-8"
+          ).strip
+          linux_path.empty? ? nil : linux_path
+        end
+      end
+
+      # Linux: standard XDG config paths for Chrome and Edge.
+      private_class_method def self.linux_user_data_dirs
+        config_home = ENV["XDG_CONFIG_HOME"] || File.join(Dir.home, ".config")
+        [
+          File.join(config_home, "microsoft-edge"),
+          File.join(config_home, "google-chrome"),
+          File.join(config_home, "google-chrome-beta"),
+          File.join(config_home, "google-chrome-unstable"),
+        ]
+      end
+
+      # macOS: Application Support paths for Chrome and Edge.
+      private_class_method def self.macos_user_data_dirs
+        base = File.join(Dir.home, "Library", "Application Support")
+        [
+          File.join(base, "Microsoft Edge"),
+          File.join(base, "Google", "Chrome"),
+          File.join(base, "Google", "Chrome Beta"),
+          File.join(base, "Google", "Chrome Canary"),
+        ]
+      end
+
+      # -----------------------------------------------------------------------
+      # Helpers
+      # -----------------------------------------------------------------------
+
+      # Parse DevToolsActivePort file.
+      # Format: first line = port number, second line = WS path
+      # @return [String, nil] ws://127.0.0.1:PORT/PATH or nil on parse error
+      private_class_method def self.parse_active_port_file(path)
+        lines = File.read(path, encoding: "utf-8").split("\n").map(&:strip).reject(&:empty?)
+        return nil unless lines.size >= 2
+
+        port = lines[0].to_i
+        ws_path = lines[1]
+        return nil if port <= 0 || port > 65_535 || ws_path.empty?
+
+        "ws://127.0.0.1:#{port}#{ws_path}"
+      rescue StandardError
+        nil
+      end
+
+      # Probe TCP port with a short timeout.
+      # Chrome 146+ dropped HTTP /json/version — TCP reachability is sufficient.
+      # @return [Boolean]
+      private_class_method def self.tcp_open?(host, port)
+        Socket.tcp(host, port, connect_timeout: TCP_PROBE_TIMEOUT) { true }
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError, Errno::EHOSTUNREACH
+        false
+      end
+    end
+  end
+end

data/lib/clacky/utils/scripts_manager.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Clacky
+  module Utils
+    # Manages user-space shell scripts in ~/.clacky/scripts/.
+    #
+    # On first use, bundled scripts are copied from the gem's scripts/
+    # directory into ~/.clacky/scripts/. The user-space copy is always
+    # used so users can customise scripts without modifying the gem.
+    #
+    # Bundled scripts are re-copied when the gem is upgraded (detected
+    # via gem version stamp in ~/.clacky/scripts/.version).
+    module ScriptsManager
+      SCRIPTS_DIR         = File.expand_path("~/.clacky/scripts").freeze
+      DEFAULT_SCRIPTS_DIR = File.expand_path("../../../../scripts", __dir__).freeze
+      VERSION_FILE        = File.join(SCRIPTS_DIR, ".version").freeze
+
+      SCRIPTS = %w[
+        install_browser.sh
+      ].freeze
+
+      # Copy bundled scripts to ~/.clacky/scripts/ if missing or outdated.
+      # Called once at agent startup — fast (no-op after first run).
+      def self.setup!
+        FileUtils.mkdir_p(SCRIPTS_DIR)
+
+        current_version = Clacky::VERSION
+        stored_version  = File.exist?(VERSION_FILE) ? File.read(VERSION_FILE).strip : nil
+
+        SCRIPTS.each do |script|
+          dest = File.join(SCRIPTS_DIR, script)
+          src  = File.join(DEFAULT_SCRIPTS_DIR, script)
+          next unless File.exist?(src)
+
+          # Copy if missing or gem was upgraded
+          if !File.exist?(dest) || stored_version != current_version
+            FileUtils.cp(src, dest)
+            FileUtils.chmod(0o755, dest)
+          end
+        end
+
+        # Write version stamp after successful copy
+        File.write(VERSION_FILE, current_version)
+      end
+
+      # Returns the full path to a managed script.
+      # @param name [String] script filename, e.g. "install_browser.sh"
+      # @return [String, nil]
+      def self.path_for(name)
+        dest = File.join(SCRIPTS_DIR, name)
+        File.exist?(dest) ? dest : nil
+      end
+    end
+  end
+end

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "0.9.21"
+  VERSION = "0.9.22"
 end

data/lib/clacky/web/tasks.js

@@ -107,8 +107,7 @@ const Tasks = (() => {
 
     /** Called by Router when the tasks panel becomes active. */
     onPanelShow() {
-      Tasks.renderTable();
-      Tasks.renderSection();
+      Tasks.load();
       const btn = $("btn-create-task");
       if (btn) btn.onclick = () => Tasks.createInSession();
     },

data/lib/clacky.rb

@@ -89,6 +89,9 @@ require_relative "clacky/ui2/progress_indicator"
 # Utils
 require_relative "clacky/utils/logger"
 require_relative "clacky/utils/encoding"
+require_relative "clacky/utils/environment_detector"
+require_relative "clacky/utils/browser_detector"
+require_relative "clacky/utils/scripts_manager"
 require_relative "clacky/utils/model_pricing"
 require_relative "clacky/utils/gitignore_parser"
 require_relative "clacky/utils/limit_stack"

data/scripts/install_browser.sh

@@ -0,0 +1,189 @@
+#!/bin/bash
+# Install Node.js (via mise) and chrome-devtools-mcp for browser automation.
+# This script is copied to ~/.clacky/scripts/ on first run and invoked by
+# the browser-setup skill when chrome-devtools-mcp is not yet installed.
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+print_info()    { echo -e "${BLUE}ℹ${NC} $1"; }
+print_success() { echo -e "${GREEN}✓${NC} $1"; }
+print_warning() { echo -e "${YELLOW}⚠${NC} $1"; }
+print_error()   { echo -e "${RED}✗${NC} $1"; }
+print_step()    { echo -e "\n${BLUE}==>${NC} $1"; }
+
+command_exists() { command -v "$1" >/dev/null 2>&1; }
+
+# --------------------------------------------------------------------------
+# Network region detection (quick — only probes google + baidu)
+# --------------------------------------------------------------------------
+SLOW_THRESHOLD_MS=5000
+USE_CN_MIRRORS=false
+DEFAULT_NPM_REGISTRY="https://registry.npmjs.org"
+CN_NPM_REGISTRY="https://registry.npmmirror.com"
+CN_NODE_MIRROR_URL="https://cdn.npmmirror.com/binaries/node/"
+DEFAULT_MISE_INSTALL_URL="https://mise.run"
+CN_MISE_INSTALL_URL="https://oss.1024code.com/mise.sh"
+MISE_INSTALL_URL="$DEFAULT_MISE_INSTALL_URL"
+NPM_REGISTRY_URL="$DEFAULT_NPM_REGISTRY"
+NODE_MIRROR_URL=""
+
+_probe_url() {
+    local url="$1"
+    local out
+    out=$(curl -s -o /dev/null -w "%{http_code} %{time_total}" \
+        --connect-timeout 5 --max-time 5 "$url" 2>/dev/null) || true
+    local http_code="${out%% *}"
+    local total_time="${out#* }"
+    if [ -z "$http_code" ] || [ "$http_code" = "000" ] || [ "$http_code" = "$out" ]; then
+        echo "timeout"; return
+    fi
+    awk -v s="$total_time" 'BEGIN { printf "%d", s * 1000 }'
+}
+
+_is_slow() {
+    local r="$1"
+    [ "$r" = "timeout" ] && return 0
+    [ "$r" -ge "$SLOW_THRESHOLD_MS" ] 2>/dev/null
+}
+
+detect_network_region() {
+    print_step "Detecting network region..."
+    local google baidu
+    google=$(_probe_url "https://www.google.com")
+    baidu=$(_probe_url "https://www.baidu.com")
+
+    if ! _is_slow "$google"; then
+        print_info "Region: global"
+    elif ! _is_slow "$baidu"; then
+        print_info "Region: china — switching to CN mirrors"
+        USE_CN_MIRRORS=true
+        MISE_INSTALL_URL="$CN_MISE_INSTALL_URL"
+        NPM_REGISTRY_URL="$CN_NPM_REGISTRY"
+        NODE_MIRROR_URL="$CN_NODE_MIRROR_URL"
+    else
+        print_warning "Region: unknown — using global defaults"
+    fi
+}
+
+# --------------------------------------------------------------------------
+# Ensure mise is available
+# --------------------------------------------------------------------------
+_mise_bin() {
+    if command_exists mise; then echo "mise"
+    elif [ -x "$HOME/.local/bin/mise" ]; then echo "$HOME/.local/bin/mise"
+    else echo ""
+    fi
+}
+
+ensure_mise() {
+    local mise
+    mise=$(_mise_bin)
+    if [ -n "$mise" ]; then
+        print_success "mise already installed"
+        export PATH="$HOME/.local/bin:$PATH"
+        eval "$("$mise" activate bash 2>/dev/null)" 2>/dev/null || true
+        return 0
+    fi
+
+    print_info "Installing mise..."
+    if curl -fsSL "$MISE_INSTALL_URL" | sh; then
+        export PATH="$HOME/.local/bin:$PATH"
+        eval "$(~/.local/bin/mise activate bash 2>/dev/null)" 2>/dev/null || true
+        print_success "mise installed"
+    else
+        print_warning "mise install failed — will rely on system Node if available"
+        return 1
+    fi
+}
+
+# --------------------------------------------------------------------------
+# Ensure Node.js >= 20 via mise
+# --------------------------------------------------------------------------
+ensure_node() {
+    print_step "Checking Node.js..."
+
+    # Already have a good node?
+    if command_exists node; then
+        local ver
+        ver=$(node --version 2>/dev/null | sed 's/v//')
+        local major="${ver%%.*}"
+        if [ "${major:-0}" -ge 20 ] 2>/dev/null; then
+            print_success "Node.js v${ver} — OK"
+            return 0
+        else
+            print_warning "Node.js v${ver} is too old (need >=20), will install via mise"
+        fi
+    fi
+
+    # Install via mise
+    if ! ensure_mise; then
+        print_error "Cannot install Node.js: mise unavailable and no suitable node found"
+        return 1
+    fi
+
+    local mise
+    mise=$(_mise_bin)
+
+    if [ "$USE_CN_MIRRORS" = true ] && [ -n "$NODE_MIRROR_URL" ]; then
+        "$mise" settings node.mirror_url="$NODE_MIRROR_URL" 2>/dev/null || true
+        print_info "Node mirror → ${NODE_MIRROR_URL}"
+    fi
+
+    print_info "Installing Node.js 22 via mise..."
+    "$mise" install node@22 >/dev/null 2>&1 || true
+    "$mise" use -g node@22 >/dev/null 2>&1 || true
+    eval "$("$mise" activate bash 2>/dev/null)" 2>/dev/null || true
+
+    if command_exists node; then
+        print_success "Node.js $(node --version) installed"
+    else
+        print_error "Node.js installation failed"
+        return 1
+    fi
+}
+
+# --------------------------------------------------------------------------
+# Install / update chrome-devtools-mcp
+# --------------------------------------------------------------------------
+install_chrome_devtools_mcp() {
+    print_step "Installing chrome-devtools-mcp..."
+
+    # Set npm registry
+    if [ "$USE_CN_MIRRORS" = true ]; then
+        npm config set registry "$NPM_REGISTRY_URL" 2>/dev/null || true
+        print_info "npm registry → ${NPM_REGISTRY_URL}"
+    fi
+
+    if npm install -g chrome-devtools-mcp@latest 2>/dev/null; then
+        print_success "chrome-devtools-mcp $(chrome-devtools-mcp --version 2>/dev/null) installed"
+    else
+        print_error "chrome-devtools-mcp installation failed"
+        print_info "Try manually: npm install -g chrome-devtools-mcp@latest"
+        return 1
+    fi
+}
+
+# --------------------------------------------------------------------------
+# Main
+# --------------------------------------------------------------------------
+main() {
+    echo ""
+    echo "Browser Automation Setup"
+    echo "========================"
+
+    detect_network_region
+    ensure_node   || exit 1
+    install_chrome_devtools_mcp || exit 1
+
+    echo ""
+    print_success "Done. Browser automation is ready."
+    echo ""
+}
+
+main "$@"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 0.9.21
+  version: 0.9.22
 platform: ruby
 authors:
 - windy
@@ -448,6 +448,7 @@ files:
 - lib/clacky/ui2/view_renderer.rb
 - lib/clacky/ui_interface.rb
 - lib/clacky/utils/arguments_parser.rb
+- lib/clacky/utils/browser_detector.rb
 - lib/clacky/utils/encoding.rb
 - lib/clacky/utils/environment_detector.rb
 - lib/clacky/utils/file_ignore_helper.rb
@@ -458,6 +459,7 @@ files:
 - lib/clacky/utils/model_pricing.rb
 - lib/clacky/utils/parser_manager.rb
 - lib/clacky/utils/path_helper.rb
+- lib/clacky/utils/scripts_manager.rb
 - lib/clacky/utils/string_matcher.rb
 - lib/clacky/utils/trash_directory.rb
 - lib/clacky/utils/workspace_rules.rb
@@ -482,6 +484,7 @@ files:
 - lib/clacky/web/ws.js
 - scripts/install.ps1
 - scripts/install.sh
+- scripts/install_browser.sh
 - scripts/install_full.sh
 - scripts/uninstall.sh
 - sig/clacky.rbs