openclacky 1.2.7 → 1.2.8

data/lib/clacky/server/channel/adapters/base.rb

@@ -15,6 +15,10 @@ module Clacky
         @registry[platform.to_sym]
       end
 
+      def self.unregister(platform)
+        @registry.delete(platform.to_sym)
+      end
+
       def self.all
         @registry.values
       end

data/lib/clacky/server/channel/channel_manager.rb

@@ -511,7 +511,7 @@ module Clacky
         platform = event[:platform].to_s
         count    = @mutex.synchronize { @session_counters[platform] += 1 }
         name     = "#{platform}-#{count}"
-        session_id = @session_builder.call(name: name, working_dir: Dir.home, source: :channel)
+        session_id = @session_builder.call(name: name, source: :channel)
         bind_key_to_session(key, session_id)
 
         # Create a long-lived ChannelUIController for this session and subscribe it

data/lib/clacky/server/channel/user_adapter_loader.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Clacky
+  module Channel
+    module Adapters
+      # Loads user-defined channel adapters from ~/.clacky/channels/<name>/adapter.rb.
+      #
+      # Each adapter file is plain Ruby that defines a subclass of
+      # Clacky::Channel::Adapters::Base and self-registers via Adapters.register,
+      # exactly like the bundled adapters. This loader only discovers and requires
+      # those files after the built-in adapters are loaded — the existing
+      # self-registration mechanism then takes over with no further wiring.
+      #
+      # A broken adapter (syntax error, missing interface methods) is isolated:
+      # it is skipped with a logged warning and never aborts the load of others.
+      module UserAdapterLoader
+        DEFAULT_DIR = File.expand_path("~/.clacky/channels")
+
+        # Required class/instance methods a user adapter must implement to be usable.
+        REQUIRED_CLASS_METHODS    = %i[platform_id platform_config].freeze
+        REQUIRED_INSTANCE_METHODS = %i[start stop send_text].freeze
+
+        Result = Struct.new(:loaded, :skipped, keyword_init: true)
+
+        # @param dir [String] directory to scan (override for tests)
+        # @return [Result] names loaded and skipped (with reasons)
+        def self.load_all(dir: DEFAULT_DIR)
+          result = Result.new(loaded: [], skipped: [])
+          if Dir.exist?(dir)
+            Dir.glob(File.join(dir, "*", "adapter.rb")).sort.each do |path|
+              name = File.basename(File.dirname(path))
+              load_one(path, name, result)
+            end
+          end
+          @last_result = result
+          result
+        end
+
+        # The result of the most recent load_all (set at startup). Lets `channel_verify`
+        # report status without re-requiring files (require is idempotent and would
+        # otherwise report already-loaded adapters as "did not register").
+        def self.last_result
+          @last_result || load_all
+        end
+
+        def self.load_one(path, name, result)
+          before = Adapters.all.dup
+
+          require path
+
+          newly = Adapters.all - before
+          klass = newly.last
+
+          unless klass
+            result.skipped << [name, "did not register an adapter (missing Adapters.register?)"]
+            log_skip(name, result.skipped.last[1])
+            return
+          end
+
+          if (missing = interface_gaps(klass)).any?
+            unregister(klass)
+            result.skipped << [name, "missing required methods: #{missing.join(", ")}"]
+            log_skip(name, result.skipped.last[1])
+            return
+          end
+
+          result.loaded << name
+          Clacky::Logger.info("[UserAdapterLoader] Loaded channel adapter '#{name}' → :#{klass.platform_id}")
+        rescue StandardError, ScriptError => e
+          result.skipped << [name, e.message]
+          log_skip(name, e.message)
+        end
+
+        def self.interface_gaps(klass)
+          missing = REQUIRED_CLASS_METHODS.reject { |m| klass.respond_to?(m) }
+          # Base defines stub instance methods that only raise NotImplementedError,
+          # so method_defined? alone passes via inheritance. Require the subclass to
+          # actually override them — i.e. the method's owner must not be Base.
+          missing += REQUIRED_INSTANCE_METHODS.reject do |m|
+            klass.method_defined?(m) && klass.instance_method(m).owner != Base
+          end
+          missing
+        end
+
+        def self.unregister(klass)
+          platform = (klass.platform_id if klass.respond_to?(:platform_id))
+          return unless platform
+
+          Adapters.unregister(platform)
+        end
+
+        def self.log_skip(name, reason)
+          Clacky::Logger.warn("[UserAdapterLoader] Skipped channel adapter '#{name}': #{reason}")
+        end
+
+        # Generate a ready-to-edit adapter skeleton at ~/.clacky/channels/<name>/adapter.rb.
+        # The skeleton already self-registers and implements the full interface with
+        # TODO markers — the author only fills in the method bodies.
+        # @return [String] path to the generated adapter.rb
+        def self.scaffold(name, dir: DEFAULT_DIR)
+          slug = name.to_s.strip.downcase.gsub(/[^a-z0-9_]+/, "_").gsub(/\A_+|_+\z/, "")
+          raise ArgumentError, "invalid channel name: #{name.inspect}" if slug.empty?
+
+          target_dir = File.join(dir, slug)
+          path = File.join(target_dir, "adapter.rb")
+          raise ArgumentError, "adapter already exists: #{path}" if File.exist?(path)
+
+          FileUtils.mkdir_p(target_dir)
+          File.write(path, skeleton(slug))
+          path
+        end
+
+        def self.skeleton(slug)
+          const = slug.split("_").map(&:capitalize).join
+          <<~RUBY
+            # frozen_string_literal: true
+
+            # User-defined channel adapter for ":#{slug}".
+            # Edit the TODO sections, then it loads automatically on next start.
+            # Verify with: clacky channel verify
+
+            module Clacky
+              module Channel
+                module Adapters
+                  class #{const}Adapter < Base
+                    def self.platform_id
+                      :#{slug}
+                    end
+
+                    # Map raw config (channels.yml `#{slug}` section) to a symbol-keyed hash.
+                    def self.platform_config(data)
+                      {
+                        # TODO: pull your credentials out of `data`
+                        # token: data["IM_#{slug.upcase}_TOKEN"] || data["token"]
+                      }.compact
+                    end
+
+                    def initialize(config)
+                      @config = config
+                    end
+
+                    # Begin receiving messages. Blocks until #stop — runs inside a Thread.
+                    # Yield one standardized event Hash per inbound message.
+                    def start(&on_message)
+                      # TODO: connect to your platform and loop, calling on_message.call(event)
+                      raise NotImplementedError
+                    end
+
+                    def stop
+                      # TODO: close connections / stop the read loop
+                    end
+
+                    # Send a plain text (or Markdown) message to a chat.
+                    # @return [Hash] { message_id: String }
+                    def send_text(chat_id, text, reply_to: nil)
+                      # TODO: call your platform's send API
+                      raise NotImplementedError
+                    end
+
+                    # Optional: validate config; return array of error strings (empty = ok).
+                    def validate_config(config)
+                      []
+                    end
+
+                    Adapters.register(platform_id, self)
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/channel.rb

@@ -31,3 +31,8 @@ require_relative "channel/adapters/dingtalk/adapter"
 require_relative "channel/channel_config"
 require_relative "channel/channel_ui_controller"
 require_relative "channel/channel_manager"
+
+# Discover and load user-defined adapters from ~/.clacky/channels/.
+# Must run after the bundled adapters so user adapters can extend or override.
+require_relative "channel/user_adapter_loader"
+Clacky::Channel::Adapters::UserAdapterLoader.load_all

data/lib/clacky/server/http_server.rb

@@ -436,8 +436,8 @@ module Clacky
         when ["GET",    "/api/billing/summary"]   then api_billing_summary(req, res)
         when ["GET",    "/api/billing/daily"]     then api_billing_daily(req, res)
         when ["GET",    "/api/billing/records"]   then api_billing_records(req, res)
-        when ["DELETE", "/api/billing/clear"]     then api_billing_clear(req, res)
-        when ["PATCH",  "/api/sessions/:id/model"] then api_switch_session_model(req, res)
+        when ["GET",    "/api/billing/sessions"]  then api_billing_sessions(req, res)
+        when ["DELETE", "/api/billing/clear"]     then api_billing_clear(req, res)        when ["PATCH",  "/api/sessions/:id/model"] then api_switch_session_model(req, res)
         when ["PATCH",  "/api/sessions/:id/working_dir"] then api_change_session_working_dir(req, res)
         else
           if method == "POST" && path.match?(%r{^/api/channels/[^/]+/send$})
@@ -1170,8 +1170,27 @@ module Clacky
         })
       end
 
-      # DELETE /api/billing/clear
-      # Clears billing records
+      # GET /api/billing/sessions
+      # Returns session-level billing summary
+      # Query params: period (day|week|month|year|all, default: month), model, limit
+      def api_billing_sessions(req, res)
+        require_relative "../billing/billing_store"
+
+        query = URI.decode_www_form(req.query_string.to_s).to_h
+        period = (query["period"] || "month").to_sym
+        model = query["model"]
+        limit = [(query["limit"] || "50").to_i, 200].min
+
+        store = Clacky::Billing::BillingStore.new
+        sessions = store.session_summary(period: period, model: model, limit: limit)
+
+        json_response(res, 200, {
+          sessions: sessions,
+          count: sessions.size
+        })
+      end
+
+      # DELETE /api/billing/clear      # Clears billing records
       # Query params: scope (today|all, default: today)
       def api_billing_clear(req, res)
         require_relative "../billing/billing_store"
@@ -4386,7 +4405,9 @@ module Clacky
       # @param working_dir [String] working directory for the agent
       # @param permission_mode [Symbol] :confirm_all (default, human present) or
       #   :auto_approve (unattended — suppresses request_user_feedback waits)
-      def build_session(name:, working_dir:, permission_mode: :confirm_all, profile: "general", source: :manual, model_id: nil)
+      def build_session(name:, working_dir: nil, permission_mode: :confirm_all, profile: "general", source: :manual, model_id: nil)
+        working_dir ||= default_working_dir
+        FileUtils.mkdir_p(working_dir) unless Dir.exist?(working_dir)
         session_id = Clacky::SessionManager.generate_id
         @registry.create(session_id: session_id)
 

data/lib/clacky/server/scheduler.rb

@@ -223,11 +223,8 @@ module Clacky
         prompt    = read_task(task_name)
         name      = "⏰ #{schedule["name"]} #{Time.now.strftime("%H:%M")}"
 
-        working_dir = File.expand_path("~/clacky_workspace")
-        FileUtils.mkdir_p(working_dir)
-
         # Scheduled tasks run unattended — use auto_approve so request_user_feedback doesn't block.
-        session_id = @session_builder.call(name: name, working_dir: working_dir, permission_mode: :auto_approve, source: :cron)
+        session_id = @session_builder.call(name: name, permission_mode: :auto_approve, source: :cron)
 
         Clacky::Logger.info("scheduler_task_fired", task: task_name, session: session_id)
 

data/lib/clacky/shell_hook_loader.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "timeout"
+require "yaml"
+require "fileutils"
+
+module Clacky
+  # Loads declarative, shell-based hooks from ~/.clacky/hooks.yml and registers
+  # them on a HookManager. Each hook runs an external command rather than Ruby in
+  # the agent process, which keeps user-authored hooks sandboxed and safe.
+  #
+  # hooks.yml format:
+  #   hooks:
+  #     before_tool_use:
+  #       - name: guard            # optional label for logs
+  #         command: "~/.clacky/hook-scripts/guard.sh"
+  #         timeout: 10            # optional, seconds (default 10)
+  #     on_complete:
+  #       - command: "notify-send done"
+  #
+  # Runtime contract (per invocation):
+  #   - The event payload is passed to the command as JSON on STDIN.
+  #   - exit 0  → allow (default).
+  #   - exit 2  → deny; STDOUT becomes the denial reason. Only meaningful for
+  #               before_tool_use, which the agent checks for {action: :deny}.
+  #   - any other exit / timeout / crash → logged, treated as allow (a broken
+  #     hook must never wedge the agent).
+  class ShellHookLoader
+    DEFAULT_PATH    = File.expand_path("~/.clacky/hooks.yml")
+    DEFAULT_TIMEOUT = 10
+    DENY_EXIT_CODE  = 2
+
+    Result = Struct.new(:registered, :skipped, keyword_init: true)
+
+    def self.load_into(hook_manager, path: DEFAULT_PATH)
+      new(path: path).load_into(hook_manager)
+    end
+
+    # Create a starter hooks.yml plus an example guard script. Idempotent-ish:
+    # raises if hooks.yml already exists so we never clobber user config.
+    # @return [String] path to the created hooks.yml
+    def self.scaffold(path: DEFAULT_PATH)
+      raise ArgumentError, "hooks file already exists: #{path}" if File.exist?(path)
+
+      dir = File.dirname(path)
+      scripts_dir = File.join(dir, "hook-scripts")
+      FileUtils.mkdir_p(scripts_dir)
+
+      guard = File.join(scripts_dir, "deny-example.sh")
+      File.write(guard, <<~SH)
+        #!/usr/bin/env bash
+        # Example before_tool_use hook.
+        # Reads the event JSON on STDIN; exit 2 to DENY, exit 0 to ALLOW.
+        # STDOUT on exit 2 becomes the denial reason shown to the agent.
+        payload="$(cat)"
+        # Example: deny any terminal command containing "rm -rf /"
+        if echo "$payload" | grep -q 'rm -rf /'; then
+          echo "blocked dangerous command"
+          exit 2
+        fi
+        exit 0
+      SH
+      FileUtils.chmod("+x", guard)
+
+      File.write(path, <<~YAML)
+        # Declarative shell hooks. Each command receives the event payload as JSON
+        # on STDIN. For before_tool_use: exit 2 = deny (STDOUT = reason), exit 0 = allow.
+        # Events: #{HookManager::HOOK_EVENTS.join(", ")}
+        hooks:
+          before_tool_use:
+            - name: deny-example
+              command: "#{guard}"
+              timeout: 10
+        #  on_complete:
+        #    - command: "echo task finished"
+      YAML
+
+      path
+    end
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+    end
+
+    # @return [Result] counts of registered hooks and skipped (with reasons)
+    def load_into(hook_manager)
+      result = Result.new(registered: [], skipped: [])
+      return result unless File.exist?(@path)
+
+      doc = YAMLCompat.load_file(@path) || {}
+      events = doc["hooks"] || {}
+
+      events.each do |event_name, specs|
+        event = event_name.to_sym
+        Array(specs).each do |spec|
+          register_one(hook_manager, event, spec, result)
+        end
+      end
+
+      result
+    rescue StandardError => e
+      Clacky::Logger.error("[ShellHookLoader] Failed to load #{@path}: #{e.message}")
+      result
+    end
+
+    private def register_one(hook_manager, event, spec, result)
+      command = spec["command"].to_s.strip
+      name    = spec["name"] || command
+      timeout = (spec["timeout"] || DEFAULT_TIMEOUT).to_i
+
+      if command.empty?
+        result.skipped << [name, "missing command"]
+        return
+      end
+
+      unless HookManager::HOOK_EVENTS.include?(event)
+        result.skipped << [name, "unknown event: #{event}"]
+        return
+      end
+
+      hook_manager.add(event) do |*args|
+        run_command(event, command, timeout, args)
+      end
+      result.registered << [event, name]
+    end
+
+    private def run_command(event, command, timeout, args)
+      payload = JSON.generate(build_payload(event, args))
+
+      out = +""
+      status = nil
+      Open3.popen3(command) do |stdin, stdout, _stderr, wait_thr|
+        stdin.write(payload)
+        stdin.close
+        if wait_thr.join(timeout)
+          out = stdout.read
+          status = wait_thr.value
+        else
+          Process.kill("TERM", wait_thr.pid) rescue nil
+          raise Timeout::Error
+        end
+      end
+
+      if status&.exitstatus == DENY_EXIT_CODE
+        { action: :deny, reason: out.strip.empty? ? "Denied by hook" : out.strip }
+      else
+        { action: :allow }
+      end
+    rescue Timeout::Error
+      Clacky::Logger.warn("[ShellHookLoader] Hook '#{command}' timed out after #{timeout}s — allowing")
+      { action: :allow }
+    rescue StandardError => e
+      Clacky::Logger.warn("[ShellHookLoader] Hook '#{command}' failed: #{e.message} — allowing")
+      { action: :allow }
+    end
+
+    # Normalize the positional trigger args of each event into a JSON-serializable hash.
+    private def build_payload(event, args)
+      base = { event: event.to_s }
+
+      case event
+      when :before_tool_use, :after_tool_use, :on_tool_error
+        base[:tool] = args[0]
+        base[:result] = args[1] if args.length > 1 && event == :after_tool_use
+        base[:error] = args[1].to_s if event == :on_tool_error && args[1]
+      when :on_start
+        base[:user_input] = args[0].to_s
+      when :on_iteration
+        base[:iteration] = args[0]
+      when :on_complete
+        base[:result] = args[0]
+      when :session_rollback
+        base[:info] = args[0]
+      end
+
+      base
+    end
+  end
+end

data/lib/clacky/version.rb

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

data/lib/clacky/web/app.css

@@ -9018,11 +9018,10 @@ body.setup-mode[data-theme="dark"] {
   transition: height 0.2s ease;
 }
 .billing-cache-miss {
-  background: #3b82f6;
+  background: #f59e0b;
   width: 100%;
   transition: height 0.2s ease;
-}
-.billing-output-bar {
+}.billing-output-bar {
   width: 12px;
   background: #10b981;
   border-radius: 2px 2px 0 0;
@@ -9038,10 +9037,10 @@ body.setup-mode[data-theme="dark"] {
 }
 
 /* Legend colors */
+.billing-legend-total { background: #6366f1; }
 .billing-legend-cache-hit { background: #93c5fd; }
-.billing-legend-cache-miss { background: #3b82f6; }
+.billing-legend-cache-miss { background: #f59e0b; }
 .billing-legend-output { background: #10b981; }
-
 /* ── Chart Tooltip ───────────────────────────────────────────────────── */
 .billing-chart-tooltip {
   display: none;
@@ -9085,10 +9084,10 @@ body.setup-mode[data-theme="dark"] {
   border-radius: 50%;
   flex-shrink: 0;
 }
+.tooltip-total { background: #6366f1; }
 .tooltip-cache-hit { background: #93c5fd; }
-.tooltip-cache-miss { background: #3b82f6; }
-.tooltip-output { background: #10b981; }
-.tooltip-label {
+.tooltip-cache-miss { background: #f59e0b; }
+.tooltip-output { background: #10b981; }.tooltip-label {
   flex: 1;
   color: var(--color-text-secondary);
 }
@@ -9155,8 +9154,8 @@ body.setup-mode[data-theme="dark"] {
   border-radius: 3px;
   transition: width 0.3s ease;
 }
-.billing-bar-prompt {
-  background: linear-gradient(90deg, #3b82f6 0%, #60a5fa 100%);
+.billing-bar-total {
+  background: linear-gradient(90deg, #6366f1 0%, #818cf8 100%);
 }
 .billing-bar-completion {
   background: linear-gradient(90deg, #10b981 0%, #34d399 100%);
@@ -9164,10 +9163,9 @@ body.setup-mode[data-theme="dark"] {
 .billing-bar-cache-read {
   background: linear-gradient(90deg, #93c5fd 0%, #bfdbfe 100%);
 }
-.billing-bar-cache-write {
-  background: linear-gradient(90deg, #6366f1 0%, #818cf8 100%);
+.billing-bar-cache-miss {
+  background: linear-gradient(90deg, #f59e0b 0%, #fbbf24 100%);
 }
-
 /* ── Model List ──────────────────────────────────────────────────────── */
 .billing-model-list {
   display: flex;
@@ -9569,3 +9567,147 @@ body.setup-mode[data-theme="dark"] {
   color: var(--color-text-secondary);
   font-weight: 500;
 }
+
+/* ── Sessions List ───────────────────────────────────────────────────── */
+.billing-sessions-row {
+  margin-top: 1rem;
+}
+.billing-sessions-section {
+  background: var(--color-bg-secondary);
+  border: 1px solid var(--color-border-primary);
+  border-radius: 12px;
+  padding: 1.25rem;
+}
+.billing-sessions-section h3 {
+  font-size: 0.9375rem;
+  font-weight: 600;
+  color: var(--color-text-primary);
+  margin: 0 0 1rem 0;
+}
+.billing-sessions-empty {
+  text-align: center;
+  padding: 2rem;
+  color: var(--color-text-secondary);
+  font-size: 0.875rem;
+}
+.billing-sessions-header {
+  display: grid;
+  grid-template-columns: 36px 1.5fr 0.8fr 0.8fr 0.8fr 0.8fr 0.8fr 1fr;
+  gap: 0.5rem;
+  padding: 0.75rem 1rem;
+  background: var(--color-bg-tertiary);
+  border-radius: 8px;
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: var(--color-text-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  margin-bottom: 0.5rem;
+}
+.billing-sessions-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+}
+.billing-session-row {
+  display: grid;
+  grid-template-columns: 36px 1.5fr 0.8fr 0.8fr 0.8fr 0.8fr 0.8fr 1fr;
+  gap: 0.5rem;
+  padding: 0.75rem 1rem;
+  border-radius: 8px;
+  transition: background 0.15s;
+  align-items: center;
+}
+.billing-session-row:hover {
+  background: var(--color-bg-tertiary);
+}
+.billing-session-deleted {
+  opacity: 0.7;
+  border-left: 3px solid var(--color-warning);
+}
+.billing-session-deleted .billing-cell-main {
+  color: var(--color-text-secondary);
+  font-style: italic;
+}
+.billing-cell {
+  font-size: 0.875rem;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.billing-cell-index {
+  font-size: 0.75rem;
+  color: var(--color-text-secondary);
+  text-align: center;
+}
+.billing-cell-session {
+  display: flex;
+  flex-direction: column;
+  gap: 0.125rem;
+  min-width: 0;
+}
+.billing-cell-main {
+  font-weight: 500;
+  color: var(--color-text-primary);
+  font-family: var(--font-mono);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.billing-cell-sub {
+  font-size: 0.7rem;
+  color: var(--color-text-secondary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.billing-cell-number {
+  font-family: var(--font-mono);
+  text-align: right;
+  color: var(--color-text-primary);
+}
+.billing-cell-hit {
+  color: #3b82f6;
+}
+.billing-cell-miss {
+  color: #f59e0b;
+}
+.billing-cell-cost {
+  font-family: var(--font-mono);
+  font-weight: 600;
+  color: var(--color-accent);
+  text-align: right;
+}
+.billing-cell-time {
+  font-size: 0.75rem;
+  color: var(--color-text-secondary);
+}
+@media (max-width: 768px) {
+  .billing-sessions-header {
+    display: none;
+  }
+  .billing-session-row {
+    grid-template-columns: 1fr 1fr;
+    gap: 0.5rem;
+    padding: 1rem;
+  }
+  .billing-cell-index {
+    display: none;
+  }
+  .billing-cell-session {
+    grid-column: 1 / -1;
+  }
+  .billing-cell-number {
+    text-align: left;
+  }
+  .billing-cell-number::before {
+    font-size: 0.625rem;
+    color: var(--color-text-secondary);
+    text-transform: uppercase;
+    display: block;
+  }
+  .billing-cell-time {
+    grid-column: 1 / -1;
+    text-align: right;
+  }
+}