openclacky 1.3.6 → 1.3.7

data/lib/clacky/extension/cli_commands.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "thor"
+require "tmpdir"
+
+module Clacky
+  # `clacky ext <subcommand>` — manage extension containers (ext.yml).
+  #
+  # Containers contribute panels (WebUI) and api (HTTP backends). This command
+  # group scaffolds, verifies, lists and hot-reloads them.
+  class CliExtensionCommands < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "new ID", "Scaffold a runnable hello-panel container at ~/.clacky/ext/local/ID/"
+    method_option :full, type: :boolean, default: false,
+                  desc: "Generate a kitchen-sink container exercising all 7 contributes types"
+    def new(id)
+      path = Clacky::ExtensionScaffold.new_container(id, full: options[:full])
+      puts "Created extension container: #{path}"
+      if options[:full]
+        puts "It contributes panels/api/skills/agents/channels/patches/hooks. Read its README.md, run `clacky ext verify`, then reload the WebUI."
+      else
+        puts "Reload the WebUI page to see the panel. Edits to view.js and handler.rb take effect on the next request — no restart needed."
+      end
+    rescue ArgumentError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "verify", "Resolve all containers across layers and report units + structured issues"
+    def verify
+      result = Clacky::ExtensionLoader.load_all
+
+      if result.units.empty? && result.errors.empty?
+        puts "No extension containers found."
+        return
+      end
+
+      result.units.each do |u|
+        case u.kind
+        when :panel
+          attach = Array(u.spec["attach"])
+          suffix = attach.empty? ? "" : ", attach=#{attach.inspect}"
+          puts "[OK]   #{u.ext_id}/#{u.id} (panel#{suffix}, #{u.layer})"
+        when :api
+          puts "[OK]   #{u.ext_id} (api → /api/ext/#{u.ext_id}/, #{u.layer})"
+        else
+          puts "[OK]   #{u.ext_id}/#{u.id} (#{u.kind}, #{u.layer})"
+        end
+      end
+
+      issues = Clacky::ExtensionVerifier.verify(result)
+      issues.each do |issue|
+        tag = issue.level == :error ? "[ERR]" : "[WARN]"
+        unit = issue.unit ? " #{issue.unit}" : ""
+        loc  = issue.file ? " [#{issue.file}]" : ""
+        hint = issue.hint ? "\n         hint: #{issue.hint}" : ""
+        puts "#{tag} #{issue.ext}#{unit} (#{issue.code}) — #{issue.message}#{loc}#{hint}"
+      end
+
+      exit 1 if issues.any? { |i| i.level == :error }
+    end
+
+    desc "list", "List resolved containers and their contributed units"
+    def list
+      result = Clacky::ExtensionLoader.load_all
+
+      if result.units.empty?
+        puts "No extension units resolved."
+        return
+      end
+
+      grouped = result.units.group_by(&:ext_id)
+      grouped.each do |ext_id, units|
+        layer = units.first.layer
+        origin = units.first.origin
+        puts "#{ext_id} (#{layer}, origin=#{origin})"
+        units.each do |u|
+          case u.kind
+          when :panel
+            attach = Array(u.spec["attach"])
+            suffix = attach.empty? ? "" : "  attach=#{attach.inspect}"
+            puts "  panel  #{u.id}#{suffix}"
+          when :api
+            puts "  api    → /api/ext/#{ext_id}/"
+          else
+            puts "  #{u.kind.to_s.ljust(6)} #{u.id}"
+          end
+        end
+      end
+
+      result.errors.each do |e|
+        puts "[ERR] #{e.ext_id} #{e.unit} — #{e.message}"
+      end
+    end
+
+    desc "pack ID", "Package a local container into a distributable zip"
+    method_option :out, type: :string, desc: "Output directory for the zip (default: current dir)"
+    def pack(id)
+      out = options[:out] || Dir.pwd
+      res = Clacky::ExtensionPackager.pack(id, out_dir: out)
+      puts "Packed #{res.ext_id} → #{res.path}"
+    rescue Clacky::ExtensionPackager::Error => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "install SOURCE", "Install a packed container (local zip path or http(s) URL) into the installed layer"
+    method_option :force, type: :boolean, default: false, desc: "Overwrite an already-installed extension of the same id"
+    def install(source)
+      res = Clacky::ExtensionPackager.install(source, force: options[:force])
+      puts "Installed #{res.ext_id} → #{res.path}"
+      puts "Reload the WebUI page to see any panels. No restart needed."
+    rescue Clacky::ExtensionPackager::Error => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "publish ID", "Pack a local container and publish it to the OpenClacky marketplace"
+    method_option :force, type: :boolean, default: false, desc: "Publish a new version of an already-published extension"
+    method_option :status, type: :string, desc: "Publish status: draft or published"
+    method_option :changelog, type: :string, desc: "Release notes for this version"
+    def publish(id)
+      unless Clacky::Identity.load.bound?
+        warn "Error: this device is not bound to a platform account. Authorize it first to publish."
+        exit 1
+      end
+
+      brand = Clacky::BrandConfig.load
+      Dir.mktmpdir("clacky-ext-publish") do |tmp|
+        res      = Clacky::ExtensionPackager.pack(id, out_dir: tmp)
+        zip_data = File.binread(res.path)
+
+        result = brand.upload_extension!(
+          res.ext_id, zip_data,
+          force:     options[:force],
+          status:    options[:status],
+          changelog: options[:changelog]
+        )
+
+        if result[:success]
+          ext = result[:extension] || {}
+          ver = (ext["latest_version"] || {})["version"]
+          puts "Published #{res.ext_id}#{ver ? " v#{ver}" : ""} → status=#{ext["status"]}"
+        elsif result[:already_exists]
+          warn "Error: #{res.ext_id} already published. Re-run with --force to publish a new version."
+          exit 1
+        else
+          warn "Error: #{result[:error]}"
+          exit 1
+        end
+      end
+    rescue Clacky::ExtensionPackager::Error => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "published", "List extensions you have published to the marketplace"
+    def published
+      brand  = Clacky::BrandConfig.load
+      result = brand.fetch_my_extensions!
+
+      unless result[:success]
+        warn "Error: #{result[:error]}"
+        exit 1
+      end
+
+      extensions = result[:extensions]
+      if extensions.empty?
+        puts "You have not published any extensions yet."
+        return
+      end
+
+      extensions.each do |ext|
+        ver   = (ext["latest_version"] || {})["version"] || ext["version"]
+        units = (ext["units"] || {}).map { |k, v| "#{v} #{k}" }.join(", ")
+        puts "#{ext["name"]}  v#{ver}  [#{ext["status"]}]#{units.empty? ? "" : "  (#{units})"}"
+      end
+    end
+
+    desc "unpublish ID", "Remove one of your published extensions from the marketplace"
+    def unpublish(id)
+      brand  = Clacky::BrandConfig.load
+      result = brand.delete_extension!(id)
+
+      if result[:success]
+        puts "Unpublished #{id}."
+      else
+        warn "Error: #{result[:error]}"
+        exit 1
+      end
+    end
+
+    desc "search [QUERY]", "Search the public extension marketplace"
+    method_option :sort, type: :string, default: "newest",
+                         desc: "Sort order: newest, updated, downloads"
+    def search(query = nil)
+      brand  = Clacky::BrandConfig.load
+      result = brand.search_extensions!(query: query, sort: options[:sort])
+
+      unless result[:success]
+        warn "Error: #{result[:error]}"
+        exit 1
+      end
+
+      extensions = result[:extensions]
+      if extensions.empty?
+        puts query ? "No extensions found for #{query.inspect}." : "No extensions available yet."
+        return
+      end
+
+      extensions.each do |ext|
+        emoji = ext["emoji"] || "🧩"
+        ver   = ext["version"]
+        units = (ext["units"] || {}).map { |k, v| "#{v} #{k}" }.join(", ")
+        name  = ext["name_zh"] || ext["name"]
+        puts "#{emoji}  #{name}#{ver ? "  v#{ver}" : ""}#{units.empty? ? "" : "  (#{units})"}"
+        desc = ext["description_zh"] || ext["description"]
+        puts "    #{desc}" if desc && !desc.to_s.strip.empty?
+      end
+    end
+
+  end
+end

data/lib/clacky/{server/api_extension_dispatcher.rb → extension/dispatcher.rb}

@@ -17,11 +17,15 @@ module Clacky
         # Public entry called from HttpServer#_dispatch_rest.
         # Returns true to indicate the request was handled (200/4xx/5xx).
         def handle(req, res, http_server:)
-          ext_id, sub_path = parse_path(req.path)
-          return not_found(res, "extension id missing") unless ext_id
+          mount_id, sub_path = parse_path(req.path)
+          return not_found(res, "extension mount id missing") unless mount_id
 
-          klass = Clacky::ApiExtension.registry[ext_id]
-          return not_found(res, "extension '#{ext_id}' not found") unless klass
+          # Lazily (re)load the handler on each request so edits to handler.rb take
+          # effect with no restart — cheap for a local app with a handful of exts.
+          Clacky::ApiExtensionLoader.ensure_fresh(mount_id)
+
+          klass = Clacky::ApiExtension.registry[mount_id]
+          return not_found(res, "extension '#{mount_id}' not found") unless klass
 
           method = req.request_method.to_s.downcase.to_sym
           route, params = find_route(klass, method, sub_path)
@@ -38,10 +42,10 @@ module Clacky
         # Tells HttpServer whether a given /api/ext/... path can skip access-key
         # auth, so the host can keep its single-source-of-truth auth logic.
         def public_path?(path, method)
-          ext_id, sub_path = parse_path(path)
-          return false unless ext_id
+          mount_id, sub_path = parse_path(path)
+          return false unless mount_id
 
-          klass = Clacky::ApiExtension.registry[ext_id]
+          klass = Clacky::ApiExtension.registry[mount_id]
           return false unless klass
           return false if klass.public_paths.empty?
 
@@ -51,16 +55,25 @@ module Clacky
           klass.public_paths.include?(route.pattern)
         end
 
+        # Local-app convenience: see ApiExtensionLoader.ensure_fresh — that is
+        # the single source of truth for per-request hot reload.
+
+        # /api/ext/<ext_id>/<sub-path> → [ext_id, "/<sub-path>"]
         private def parse_path(path)
           return [nil, nil] unless path.to_s.start_with?(MOUNT_PREFIX)
 
           tail = path[MOUNT_PREFIX.length..]
           slash = tail.index("/")
           if slash
-            [tail[0...slash], tail[slash..]]
+            ext_id = tail[0...slash]
+            sub = tail[slash..]
           else
-            [tail, "/"]
+            ext_id = tail
+            sub = "/"
           end
+          return [nil, nil] if ext_id.empty?
+
+          [ext_id, sub]
         end
 
         private def find_route(klass, method, sub_path)

data/lib/clacky/extension/hook_loader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Clacky
+  # Loads Ruby hook files contributed by ext.yml containers
+  # (`contributes.hooks: [{ event, file }]`). Each file is required once at
+  # process start; it registers callbacks via `Clacky::ExtensionHookRegistry.add`.
+  # Every agent then copies those callbacks onto its own `HookManager` during
+  # init, so each agent gets its own isolated hook chain.
+  module ExtensionHookLoader
+    Result = Struct.new(:registered, :skipped, keyword_init: true)
+
+    def self.load_all
+      result = Result.new(registered: [], skipped: [])
+      units = Array(Clacky::ExtensionLoader.last_result&.hooks)
+      units.each do |unit|
+        event = unit.spec["event"].to_sym
+        unless Clacky::HookManager::HOOK_EVENTS.include?(event)
+          msg = "unknown event: #{event}"
+          result.skipped << [unit.id, msg]
+          Clacky::Logger.warn("[ExtensionHookLoader] #{unit.ext_id}/#{unit.id}: #{msg}")
+          next
+        end
+
+        Clacky::ExtensionHookRegistry.current_event = event
+        require unit.spec["file_abs"]
+        result.registered << [unit.ext_id, unit.id, event]
+      rescue StandardError, ScriptError => e
+        result.skipped << [unit.id, e.message]
+        Clacky::Logger.warn("[ExtensionHookLoader] #{unit.ext_id}/#{unit.id}: #{e.message}")
+      ensure
+        Clacky::ExtensionHookRegistry.current_event = nil
+      end
+      @last_result = result
+      result
+    end
+
+    def self.last_result
+      @last_result || load_all
+    end
+  end
+
+  # Process-wide registry for ext-contributed hook callbacks. Callbacks are
+  # registered once at file load time; each new agent copies them onto its own
+  # HookManager during init via `apply_to`.
+  module ExtensionHookRegistry
+    @callbacks = Hash.new { |h, k| h[k] = [] }
+    @current_event = nil
+
+    class << self
+      attr_accessor :current_event
+
+      # Register a callback. `event` falls back to the loader-set context so
+      # ext hook files can call `add { ... }` without repeating the event name
+      # already declared in ext.yml.
+      def add(event = nil, &block)
+        ev = (event || @current_event)
+        raise ArgumentError, "ExtensionHookRegistry.add called outside a hook file" unless ev
+
+        @callbacks[ev.to_sym] << block
+      end
+
+      def callbacks
+        @callbacks
+      end
+
+      def apply_to(hook_manager)
+        @callbacks.each do |event, blocks|
+          blocks.each { |b| hook_manager.add(event, &b) }
+        end
+      end
+
+      def clear!
+        @callbacks.clear
+      end
+    end
+  end
+end