openclacky 0.9.19 → 0.9.21

data/lib/clacky/server/http_server.rb

@@ -315,11 +315,8 @@ module Clacky
         case [method, path]
         when ["GET",    "/api/sessions"]      then api_list_sessions(req, res)
         when ["POST",   "/api/sessions"]      then api_create_session(req, res)
-        when ["GET",    "/api/schedules"]     then api_list_schedules(res)
-        when ["POST",   "/api/schedules"]     then api_create_schedule(req, res)
-        when ["GET",    "/api/tasks"]         then api_list_tasks(res)
-        when ["POST",   "/api/tasks"]         then api_create_task(req, res)
-        when ["POST",   "/api/tasks/run"]     then api_run_task(req, res)
+        when ["GET",    "/api/cron-tasks"]    then api_list_cron_tasks(res)
+        when ["POST",   "/api/cron-tasks"]    then api_create_cron_task(req, res)
         when ["GET",    "/api/skills"]         then api_list_skills(res)
         when ["GET",    "/api/config"]        then api_get_config(res)
         when ["POST",   "/api/config"]        then api_save_config(req, res)
@@ -365,15 +362,15 @@ module Clacky
           elsif method == "DELETE" && path.start_with?("/api/sessions/")
             session_id = path.sub("/api/sessions/", "")
             api_delete_session(session_id, res)
-          elsif method == "DELETE" && path.start_with?("/api/schedules/")
-            name = URI.decode_www_form_component(path.sub("/api/schedules/", ""))
-            api_delete_schedule(name, res)
-          elsif method == "GET" && path.start_with?("/api/tasks/")
-            name = URI.decode_www_form_component(path.sub("/api/tasks/", ""))
-            api_get_task(name, res)
-          elsif method == "DELETE" && path.start_with?("/api/tasks/")
-            name = URI.decode_www_form_component(path.sub("/api/tasks/", ""))
-            api_delete_task(name, res)
+          elsif method == "POST" && path.match?(%r{^/api/cron-tasks/[^/]+/run$})
+            name = URI.decode_www_form_component(path.sub("/api/cron-tasks/", "").sub("/run", ""))
+            api_run_cron_task(name, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/cron-tasks/[^/]+$})
+            name = URI.decode_www_form_component(path.sub("/api/cron-tasks/", ""))
+            api_update_cron_task(name, req, res)
+          elsif method == "DELETE" && path.match?(%r{^/api/cron-tasks/[^/]+$})
+            name = URI.decode_www_form_component(path.sub("/api/cron-tasks/", ""))
+            api_delete_cron_task(name, res)
           elsif method == "PATCH" && path.match?(%r{^/api/skills/[^/]+/toggle$})
             name = URI.decode_www_form_component(path.sub("/api/skills/", "").sub("/toggle", ""))
             api_toggle_skill(name, req, res)
@@ -1242,109 +1239,81 @@ module Clacky
         }
       end
 
-      # ── Schedules API ─────────────────────────────────────────────────────────
 
-      def api_list_schedules(res)
-        json_response(res, 200, { schedules: @scheduler.schedules })
+      # ── Cron-Tasks API ───────────────────────────────────────────────────────
+      # Unified API that manages task file + schedule as a single resource.
+
+      # GET /api/cron-tasks
+      def api_list_cron_tasks(res)
+        json_response(res, 200, { cron_tasks: @scheduler.list_cron_tasks })
       end
 
-      def api_create_schedule(req, res)
-        body = parse_json_body(req)
-        name = body["name"].to_s.strip
-        task = body["task"].to_s.strip
-        cron = body["cron"].to_s.strip
+      # POST /api/cron-tasks — create task file + schedule in one step
+      # Body: { name, content, cron, enabled? }
+      def api_create_cron_task(req, res)
+        body    = parse_json_body(req)
+        name    = body["name"].to_s.strip
+        content = body["content"].to_s
+        cron    = body["cron"].to_s.strip
+        enabled = body.key?("enabled") ? body["enabled"] : true
 
-        if name.empty? || task.empty? || cron.empty?
-          json_response(res, 422, { error: "name, task, and cron are required" })
-          return
-        end
+        return json_response(res, 422, { error: "name is required" })    if name.empty?
+        return json_response(res, 422, { error: "content is required" }) if content.empty?
+        return json_response(res, 422, { error: "cron is required" })    if cron.empty?
 
-        unless @scheduler.list_tasks.include?(task)
-          json_response(res, 422, { error: "Task not found: #{task}" })
-          return
+        fields = cron.strip.split(/\s+/)
+        unless fields.size == 5
+          return json_response(res, 422, { error: "cron must have 5 fields (min hour dom month dow)" })
         end
 
-        @scheduler.add_schedule(name: name, task: task, cron: cron)
+        @scheduler.create_cron_task(name: name, content: content, cron: cron, enabled: enabled)
         json_response(res, 201, { ok: true, name: name })
       end
 
-      def api_delete_schedule(name, res)
-        if @scheduler.remove_schedule(name)
-          json_response(res, 200, { ok: true })
-        else
-          json_response(res, 404, { error: "Schedule not found: #{name}" })
-        end
-      end
-
-      # ── Tasks API ─────────────────────────────────────────────────────────────
+      # PATCH /api/cron-tasks/:name — update content and/or cron/enabled
+      # Body: { content?, cron?, enabled? }
+      def api_update_cron_task(name, req, res)
+        body    = parse_json_body(req)
+        content = body["content"]
+        cron    = body["cron"]&.to_s&.strip
+        enabled = body["enabled"]
 
-      def api_list_tasks(res)
-        tasks = @scheduler.list_tasks.map do |name|
-          content = begin
-            @scheduler.read_task(name)
-          rescue StandardError
-            ""
-          end
-          { name: name, path: @scheduler.task_file_path(name), content: content }
+        if cron && cron.split(/\s+/).size != 5
+          return json_response(res, 422, { error: "cron must have 5 fields (min hour dom month dow)" })
         end
-        json_response(res, 200, { tasks: tasks })
-      end
 
-      def api_get_task(name, res)
-        content = @scheduler.read_task(name)
-        json_response(res, 200, { name: name, content: content })
+        @scheduler.update_cron_task(name, content: content, cron: cron, enabled: enabled)
+        json_response(res, 200, { ok: true, name: name })
       rescue => e
         json_response(res, 404, { error: e.message })
       end
 
-      def api_delete_task(name, res)
-        if @scheduler.delete_task(name)
+      # DELETE /api/cron-tasks/:name — remove task file + schedule
+      def api_delete_cron_task(name, res)
+        if @scheduler.delete_cron_task(name)
           json_response(res, 200, { ok: true })
         else
-          json_response(res, 404, { error: "Task not found: #{name}" })
+          json_response(res, 404, { error: "Cron task not found: #{name}" })
         end
       end
 
-      def api_create_task(req, res)
-        body    = parse_json_body(req)
-        name    = body["name"].to_s.strip
-        content = body["content"].to_s
-
-        if name.empty?
-          json_response(res, 422, { error: "name is required" })
-          return
-        end
-
-        @scheduler.write_task(name, content)
-        json_response(res, 201, { ok: true, name: name })
-      end
-
-      def api_run_task(req, res)
-        body = parse_json_body(req)
-        name = body["name"].to_s.strip
-
-        if name.empty?
-          json_response(res, 422, { error: "name is required" })
-          return
+      # POST /api/cron-tasks/:name/run — execute immediately
+      def api_run_cron_task(name, res)
+        unless @scheduler.list_tasks.include?(name)
+          return json_response(res, 404, { error: "Cron task not found: #{name}" })
         end
 
-        begin
-          prompt       = @scheduler.read_task(name)
-          session_name = "▶ #{name} #{Time.now.strftime("%H:%M")}"
-          working_dir  = File.expand_path("~/clacky_workspace")
-          FileUtils.mkdir_p(working_dir)
-
-          # Tasks run unattended — use auto_approve so request_user_feedback doesn't block.
-          session_id = build_session(name: session_name, working_dir: working_dir, permission_mode: :auto_approve)
+        prompt       = @scheduler.read_task(name)
+        session_name = "▶ #{name} #{Time.now.strftime("%H:%M")}"
+        working_dir  = File.expand_path("~/clacky_workspace")
+        FileUtils.mkdir_p(working_dir)
 
-          # Store the pending task prompt so the WS "run_task" message can start it
-          # after the client has subscribed and is ready to receive broadcasts.
-          @registry.update(session_id, pending_task: prompt, pending_working_dir: working_dir)
+        session_id = build_session(name: session_name, working_dir: working_dir, permission_mode: :auto_approve)
+        @registry.update(session_id, pending_task: prompt, pending_working_dir: working_dir)
 
-          json_response(res, 202, { ok: true, session: @registry.session_summary(session_id) })
-        rescue => e
-          json_response(res, 422, { error: e.message })
-        end
+        json_response(res, 202, { ok: true, session: @registry.session_summary(session_id) })
+      rescue => e
+        json_response(res, 422, { error: e.message })
       end
 
       # ── Skills API ────────────────────────────────────────────────────────────

data/lib/clacky/server/scheduler.rb

@@ -85,6 +85,61 @@ module Clacky
         list.size < before_count
       end
 
+      # Update an existing schedule entry (cron and/or enabled).
+      # Returns false if the schedule does not exist.
+      def update_schedule(name, cron: nil, enabled: nil)
+        list = load_schedules
+        entry = list.find { |s| s["name"] == name }
+        return false unless entry
+
+        entry["cron"]    = cron    unless cron.nil?
+        entry["enabled"] = enabled unless enabled.nil?
+        save_schedules(list)
+        true
+      end
+
+      # ── Composite cron-task helpers ──────────────────────────────────────────
+
+      # Create a task file and its schedule in one step.
+      def create_cron_task(name:, content:, cron:, enabled: true)
+        write_task(name, content)
+        add_schedule(name: name, task: name, cron: cron, enabled: enabled)
+      end
+
+      # Update a cron-task: optionally update content and/or schedule fields.
+      def update_cron_task(name, content: nil, cron: nil, enabled: nil)
+        raise "Cron task not found: #{name}" unless list_tasks.include?(name)
+
+        write_task(name, content) unless content.nil?
+        update_schedule(name, cron: cron, enabled: enabled) if cron || !enabled.nil?
+      end
+
+      # Delete a cron-task: remove both the task file and its schedule.
+      def delete_cron_task(name)
+        removed_schedule = remove_schedule(name)
+        removed_task     = delete_task(name)
+        removed_schedule || removed_task
+      end
+
+      # Return a merged list of cron-tasks (task content + schedule metadata).
+      def list_cron_tasks
+        schedule_map = load_schedules.each_with_object({}) do |s, h|
+          h[s["task"]] = s if s.is_a?(Hash)
+        end
+
+        list_tasks.map do |task_name|
+          content  = begin; read_task(task_name); rescue StandardError; ""; end
+          schedule = schedule_map[task_name] || {}
+          {
+            "name"    => task_name,
+            "content" => content,
+            "cron"    => schedule["cron"],
+            "enabled" => schedule.fetch("enabled", true),
+            "scheduled" => !schedule.empty?
+          }
+        end
+      end
+
       # ── Task file helpers ────────────────────────────────────────────────────
 
       # Read the prompt content of a named task.

data/lib/clacky/tools/browser.rb

@@ -486,7 +486,7 @@ module Clacky
       # -----------------------------------------------------------------------
 
       private def find_node_binary
-        path = `which node 2>/dev/null`.strip
+        path = Clacky::Utils::Encoding.cmd_to_utf8(`which node 2>/dev/null`, source_encoding: "UTF-8").strip
         return nil if path.empty? || !File.executable?(path)
         path
       end
@@ -494,7 +494,7 @@ module Clacky
       private def node_major_version
         node = find_node_binary
         return nil unless node
-        `#{node} --version 2>/dev/null`.strip.gsub(/^v/, "").split(".").first.to_i
+        Clacky::Utils::Encoding.cmd_to_utf8(`#{node} --version 2>/dev/null`, source_encoding: "UTF-8").strip.gsub(/^v/, "").split(".").first.to_i
       end
 
       private def node_error

data/lib/clacky/utils/encoding.rb

@@ -54,6 +54,27 @@ module Clacky
         str.encode("UTF-8", "UTF-8", invalid: :replace, undef: :replace, replace: "")
       end
 
+      # Convert raw shell command output to valid UTF-8.
+      # Handles two common cases:
+      #   - Windows commands (e.g. powershell.exe) that output GBK/CP936 bytes
+      #   - Unix commands that output UTF-8 or ASCII bytes with ASCII-8BIT encoding
+      #
+      # Strategy: try GBK decode first (superset of ASCII, covers Chinese Windows);
+      # if that fails fall back to UTF-8 scrub.
+      #
+      # @param data [String, nil] raw bytes from backtick / IO.popen
+      # @param source_encoding [String] hint for source encoding (default: "GBK")
+      # @return [String] valid UTF-8 string
+      def self.cmd_to_utf8(data, source_encoding: "GBK")
+        return "" if data.nil? || data.empty?
+
+        data.dup
+            .force_encoding(source_encoding)
+            .encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+        to_utf8(data)
+      end
+
       # Return an ASCII-safe UTF-8 copy of *str* suitable for security regex
       # pattern matching.  Any byte that is not valid in the source encoding, or
       # that cannot be represented in UTF-8, is replaced with '?'.  The

data/lib/clacky/utils/environment_detector.rb

@@ -55,29 +55,32 @@ module Clacky
       end
 
       private_class_method def self.wsl_desktop_path
-        if `which powershell.exe 2>/dev/null`.strip.empty?
+        if Utils::Encoding.cmd_to_utf8(`which powershell.exe 2>/dev/null`).strip.empty?
           return fallback_desktop_path
         end
 
-        win_path = `powershell.exe -NoProfile -Command '[Environment]::GetFolderPath("Desktop")' 2>/dev/null`
-                     .strip.tr("\r\n", "")
+        # powershell.exe on Chinese Windows outputs GBK bytes; decode explicitly
+        win_path = Utils::Encoding.cmd_to_utf8(
+          `powershell.exe -NoProfile -Command '[Environment]::GetFolderPath("Desktop")' 2>/dev/null`
+        ).strip.tr("\r\n", "")
         return fallback_desktop_path if win_path.empty?
 
-        linux_path = `wslpath '#{win_path}' 2>/dev/null`.strip
+        # wslpath output is UTF-8 (Linux side)
+        linux_path = Utils::Encoding.cmd_to_utf8(`wslpath '#{win_path}' 2>/dev/null`, source_encoding: "UTF-8").strip
         return linux_path if !linux_path.empty? && Dir.exist?(linux_path)
 
         fallback_desktop_path
       end
 
       private_class_method def self.linux_desktop_path
-        path = `xdg-user-dir DESKTOP 2>/dev/null`.strip
+        path = Utils::Encoding.cmd_to_utf8(`xdg-user-dir DESKTOP 2>/dev/null`, source_encoding: "UTF-8").strip
         return path if !path.empty? && path != Dir.home && Dir.exist?(path)
 
         fallback_desktop_path
       end
 
       private_class_method def self.macos_desktop_path
-        path = `osascript -e 'POSIX path of (path to desktop)' 2>/dev/null`.strip.chomp("/")
+        path = Utils::Encoding.cmd_to_utf8(`osascript -e 'POSIX path of (path to desktop)' 2>/dev/null`, source_encoding: "UTF-8").strip.chomp("/")
         return path if !path.empty? && Dir.exist?(path)
 
         fallback_desktop_path

data/lib/clacky/version.rb

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

data/lib/clacky/web/app.css

@@ -938,7 +938,7 @@ body {
 .task-btn-run  { background: var(--color-accent-primary); color: #fff; }
 .task-btn-run:hover  { background: var(--color-accent-hover); }
 .task-btn-edit { background: var(--color-border-primary); color: var(--color-text-primary); }
-.task-btn-edit:hover { background: #3d444d; }
+.task-btn-edit:hover { background: var(--color-bg-hover); }
 .task-btn-del  { background: var(--color-error-bg); color: var(--color-error); }
 .task-btn-del:hover  { background: var(--color-error); color: #fff; }
 

data/lib/clacky/web/tasks.js

@@ -14,27 +14,18 @@
 
 const Tasks = (() => {
   // ── Private state ──────────────────────────────────────────────────────
-  let _tasks     = [];   // [{ name, path, content, schedules: Schedule[] }]
-  let _schedules = [];   // [{ name, task, cron, enabled }]
+  let _tasks = [];   // [{ name, content, cron, enabled, scheduled }]
 
   // ── Private helpers ────────────────────────────────────────────────────
 
-  /** Merge schedule info into task objects. Pure function. */
-  function _attachSchedules(tasks, schedules) {
-    return tasks.map(t => ({
-      ...t,
-      schedules: schedules.filter(s => s.task === t.name)
-    }));
-  }
-
   /** Render a single task row in the main panel table. */
   function _renderTaskRow(t) {
     const row = document.createElement("div");
     row.className = "task-table-row";
     row.dataset.name = t.name;
 
-    const schedLabel = t.schedules.length > 0
-      ? escapeHtml(t.schedules[0].cron)
+    const schedLabel = t.scheduled
+      ? escapeHtml(t.cron)
       : `<span class="sched-manual">${I18n.t("tasks.manual")}</span>`;
 
           const preview = (t.content || "")
@@ -99,17 +90,12 @@ const Tasks = (() => {
 
     // ── Data ─────────────────────────────────────────────────────────────
 
-    /** Fetch tasks + schedules from server; re-render sidebar + panel if open. */
+    /** Fetch cron tasks from server; re-render sidebar + panel if open. */
     async load() {
       try {
-        const [tr, sr] = await Promise.all([
-          fetch("/api/tasks"),
-          fetch("/api/schedules")
-        ]);
-        const td = await tr.json();
-        const sd = await sr.json();
-        _schedules = sd.schedules || [];
-        _tasks     = _attachSchedules(td.tasks || [], _schedules);
+        const res  = await fetch("/api/cron-tasks");
+        const data = await res.json();
+        _tasks = data.cron_tasks || [];
         Tasks.renderSection();
         if (Router.current === "tasks") Tasks.renderTable();
       } catch (e) {
@@ -175,10 +161,8 @@ const Tasks = (() => {
     // ── CRUD ─────────────────────────────────────────────────────────────
 
     async run(name) {
-      const res = await fetch("/api/tasks/run", {
-        method:  "POST",
-        headers: { "Content-Type": "application/json" },
-        body:    JSON.stringify({ name })
+      const res = await fetch(`/api/cron-tasks/${encodeURIComponent(name)}/run`, {
+        method: "POST"
       });
       const data = await res.json();
       if (!res.ok) { alert(I18n.t("tasks.runError") + (data.error || "unknown")); return; }
@@ -255,7 +239,7 @@ const Tasks = (() => {
 
     async delete(name) {
       if (!confirm(I18n.t("tasks.confirmDelete", { name }))) return;
-      const res = await fetch(`/api/tasks/${encodeURIComponent(name)}`, { method: "DELETE" });
+      const res = await fetch(`/api/cron-tasks/${encodeURIComponent(name)}`, { method: "DELETE" });
       if (!res.ok) { alert(I18n.t("tasks.deleteError")); return; }
 
       await Tasks.load();

data/scripts/install.ps1

@@ -17,7 +17,7 @@
 # After rebooting, run the same command again to complete installation.
 #
 # Development: .\install.ps1 -Local
-#   Uses install_simple.sh from the same directory as this script instead of CDN.
+#   Uses install.sh from the same directory as this script instead of CDN.
 
 param(
     [switch]$Local,
@@ -33,7 +33,7 @@ $global:DisplayCmd  = if ($CommandName) { $CommandName } else { "openclacky" }
 
 $CLACKY_CDN_BASE_URL   = "https://oss.1024code.com"
 $INSTALL_PS1_COMMAND   = "powershell -c `"irm $CLACKY_CDN_BASE_URL/clacky-ai/openclacky/main/scripts/install.ps1 | iex`""
-$INSTALL_SCRIPT_URL    = "$CLACKY_CDN_BASE_URL/clacky-ai/openclacky/main/scripts/install_simple.sh"
+$INSTALL_SCRIPT_URL    = "$CLACKY_CDN_BASE_URL/clacky-ai/openclacky/main/scripts/install.sh"
 $UBUNTU_WSL_AMD64_URL        = "$CLACKY_CDN_BASE_URL/ubuntu-jammy-wsl-amd64-ubuntu22.04lts.rootfs.tar.gz"
 $UBUNTU_WSL_AMD64_SHA256_URL = "$CLACKY_CDN_BASE_URL/ubuntu-jammy-wsl-amd64-ubuntu22.04lts.rootfs.tar.gz.sha256"
 $UBUNTU_WSL_ARM64_URL        = "$CLACKY_CDN_BASE_URL/ubuntu-jammy-wsl-arm64-ubuntu22.04lts.rootfs.tar.gz"
@@ -245,9 +245,9 @@ function Run-InstallInWsl {
     if ($Local) {
         # Convert Windows path to WSL path (e.g. C:\foo\bar -> /mnt/c/foo/bar)
         $scriptDir = Split-Path -Parent $MyInvocation.PSCommandPath
-        $localScript = Join-Path $scriptDir "install_simple.sh"
+        $localScript = Join-Path $scriptDir "install.sh"
         if (-not (Test-Path $localScript)) {
-            Write-Fail "Local mode: install_simple.sh not found at $localScript"
+            Write-Fail "Local mode: install.sh not found at $localScript"
             exit 1
         }
         $wslPath = ($localScript -replace '\', '/') -replace '^([A-Za-z]):', { '/mnt/' + $args[0].Groups[1].Value.ToLower() }

data/scripts/install.sh

@@ -368,9 +368,19 @@ ensure_ruby() {
         return 0
     fi
 
-    # No suitable Ruby — install via mise
+    # Linux: try apt first (fast, Ubuntu 22.04 ships Ruby 3.0)
+    if [ "$OS" = "Linux" ] && ([ "$DISTRO" = "ubuntu" ] || [ "$DISTRO" = "debian" ]); then
+        print_info "Installing Ruby via apt..."
+        if sudo apt-get install -y ruby ruby-dev 2>/dev/null && check_ruby; then
+            return 0
+        fi
+        print_warning "apt Ruby install failed or version too old, falling back to mise..."
+    fi
+
+    # Fallback: install via mise (compiles from source)
     print_step "Installing Ruby via mise..."
     detect_shell
+    install_linux_build_deps
 
     if ! install_mise; then
         return 1
@@ -390,29 +400,37 @@ ensure_ruby() {
 }
 
 # --------------------------------------------------------------------------
-# Linux: install build deps before mise/Ruby (compile fallback)
+# Linux: configure apt mirror + update (always runs before any apt install)
 # --------------------------------------------------------------------------
-install_linux_build_deps() {
-    if [ "$DISTRO" = "ubuntu" ] || [ "$DISTRO" = "debian" ]; then
-        print_step "Installing build dependencies..."
-
-        if [ "$USE_CN_MIRRORS" = true ]; then
-            print_info "Configuring apt mirror (Aliyun)..."
-            local codename="${VERSION_CODENAME:-jammy}"
-            local mirror_base="https://mirrors.aliyun.com/ubuntu/"
-            local components="main restricted universe multiverse"
-            sudo tee /etc/apt/sources.list > /dev/null <<EOF
+setup_apt_mirror() {
+    if [ "$DISTRO" != "ubuntu" ] && [ "$DISTRO" != "debian" ]; then return 0; fi
+
+    if [ "$USE_CN_MIRRORS" = true ]; then
+        print_info "Configuring apt mirror (Aliyun)..."
+        local codename="${VERSION_CODENAME:-jammy}"
+        local mirror_base="https://mirrors.aliyun.com/ubuntu/"
+        local components="main restricted universe multiverse"
+        sudo tee /etc/apt/sources.list > /dev/null <<EOF
 deb ${mirror_base} ${codename} ${components}
 deb ${mirror_base} ${codename}-updates ${components}
 deb ${mirror_base} ${codename}-backports ${components}
 deb ${mirror_base} ${codename}-security ${components}
 EOF
-        fi
-
-        sudo apt update
-        sudo apt install -y build-essential libssl-dev libyaml-dev zlib1g-dev libgmp-dev git
-        print_success "Build dependencies installed"
     fi
+
+    sudo apt-get update -qq
+    print_success "apt updated"
+}
+
+# --------------------------------------------------------------------------
+# Linux: install build deps (only needed when compiling Ruby via mise)
+# --------------------------------------------------------------------------
+install_linux_build_deps() {
+    if [ "$DISTRO" != "ubuntu" ] && [ "$DISTRO" != "debian" ]; then return 0; fi
+
+    print_step "Installing build dependencies..."
+    sudo apt-get install -y build-essential libssl-dev libyaml-dev zlib1g-dev libgmp-dev git
+    print_success "Build dependencies installed"
 }
 
 # --------------------------------------------------------------------------
@@ -434,19 +452,18 @@ setup_gem_home() {
 
     export GEM_HOME="$HOME/.gem/ruby/${ruby_api}"
     export GEM_PATH="$HOME/.gem/ruby/${ruby_api}"
-    export PATH="$HOME/.local/bin:$HOME/.gem/ruby/${ruby_api}/bin:$PATH"
+    export PATH="$HOME/.gem/ruby/${ruby_api}/bin:$PATH"
 
     print_info "System Ruby detected — gems will install to ~/.gem/ruby/${ruby_api}"
 
     # Persist to shell rc (use $HOME so the line is portable)
-    # Also add ~/.local/bin so brand wrapper commands installed there are found
     if [ -n "$SHELL_RC" ] && ! grep -q "GEM_HOME" "$SHELL_RC" 2>/dev/null; then
         {
             echo ""
             echo "# Ruby user gem dir (added by openclacky installer)"
             echo "export GEM_HOME=\"\$HOME/.gem/ruby/${ruby_api}\""
             echo "export GEM_PATH=\"\$HOME/.gem/ruby/${ruby_api}\""
-            echo "export PATH=\"\$HOME/.local/bin:\$HOME/.gem/ruby/${ruby_api}/bin:\$PATH\""
+            echo "export PATH=\"\$HOME/.gem/ruby/${ruby_api}/bin:\$PATH\""
         } >> "$SHELL_RC"
         print_info "GEM_HOME written to $SHELL_RC"
     fi
@@ -524,8 +541,17 @@ YAML
     print_success "Brand config written to $brand_file"
 
     if [ -n "$BRAND_COMMAND" ]; then
-        local bin_dir="$HOME/.local/bin"
-        mkdir -p "$bin_dir"
+        # Install wrapper in the same directory as the openclacky binary so it is
+        # always on PATH regardless of whether we are running as root or a normal user.
+        local clacky_bin bin_dir
+        clacky_bin=$(command -v openclacky 2>/dev/null || true)
+        if [ -n "$clacky_bin" ]; then
+            bin_dir=$(dirname "$clacky_bin")
+        else
+            print_warning "openclacky binary not found in PATH; skipping wrapper install"
+            return 0
+        fi
+
         local wrapper="$bin_dir/$BRAND_COMMAND"
         cat > "$wrapper" <<WRAPPER
 #!/bin/sh
@@ -533,13 +559,6 @@ exec openclacky "\$@"
 WRAPPER
         chmod +x "$wrapper"
         print_success "Wrapper installed: $wrapper"
-
-        case ":$PATH:" in
-            *":$bin_dir:"*) ;;
-            *)
-                print_warning "Add to your shell profile: export PATH=\"\$HOME/.local/bin:\$PATH\""
-                ;;
-        esac
     fi
 }
 
@@ -579,10 +598,10 @@ main() {
     detect_shell
     detect_network_region
 
-    # Linux: install build deps first (needed if mise has to compile Ruby)
+    # Linux: configure apt mirror + update (always runs; build deps deferred to mise fallback)
     if [ "$OS" = "Linux" ]; then
         if [ "$DISTRO" = "ubuntu" ] || [ "$DISTRO" = "debian" ]; then
-            install_linux_build_deps
+            setup_apt_mirror
         else
             print_error "Unsupported Linux distribution: $DISTRO"
             print_info "Please install Ruby >= 2.6.0 manually and run: gem install openclacky"