openclacky 1.0.2 → 1.0.3

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

@@ -4,9 +4,10 @@ description: |
   Configure IM platform channels (Feishu, WeCom, Weixin) for openclacky.
   Uses browser automation for navigation; guides the user to paste credentials and perform UI steps.
   Trigger on: "channel setup", "setup feishu", "setup wecom", "setup weixin", "setup wechat", "channel config",
-  "channel status", "channel enable", "channel disable", "channel reconfigure", "channel doctor".
-  Subcommands: setup, status, enable <platform>, disable <platform>, reconfigure, doctor.
-argument-hint: "setup | status | enable <platform> | disable <platform> | reconfigure | doctor"
+  "channel status", "channel enable", "channel disable", "channel reconfigure", "channel doctor",
+  "send message to weixin", "send message to feishu", "send message to wecom".
+  Subcommands: setup, status, enable <platform>, disable <platform>, reconfigure, doctor, send.
+argument-hint: "setup | status | enable <platform> | disable <platform> | reconfigure | doctor | send <platform> <message>"
 allowed-tools:
   - Bash
   - Read
@@ -33,6 +34,7 @@ Configure IM platform channels for openclacky.
 | `channel disable feishu/wecom/weixin` | disable |
 | `channel reconfigure` | reconfigure |
 | `channel doctor` | doctor |
+| `send <message> to weixin/feishu/wecom` | send |
 
 ---
 
@@ -347,6 +349,58 @@ Check each item, report ✅ / ❌ with remediation:
 
 ---
 
+## `send`
+
+Proactively send a message to a user via an IM channel adapter.
+
+### Parse the request
+
+Extract two things from the user's instruction:
+- **platform** — one of `weixin`, `feishu`, `wecom`
+- **message** — the text content to send
+
+If the platform cannot be inferred, ask the user to clarify.
+
+### Step 1 — Resolve target user (optional)
+
+If the user specified a `user_id`, use it directly.
+
+Otherwise, list known users first:
+
+```bash
+curl -s http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/channels/<platform>/users
+```
+
+- If the list is **empty**: tell the user "No known users for `<platform>`. The target user must send at least one message to the bot before proactive messaging is possible." Stop here.
+- If there is **exactly one** user: use it silently.
+- If there are **multiple** users: show the list and ask which one to send to, unless the user already specified one.
+
+### Step 2 — Send the message
+
+```bash
+curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/channels/<platform>/send \
+  -H "Content-Type: application/json" \
+  -d '{"message": "<message>", "user_id": "<user_id>"}'
+```
+
+**Response handling:**
+
+| HTTP status | Meaning | Action |
+|---|---|---|
+| `200 { ok: true }` | Delivered | Tell user: "✅ Message sent to `<platform>`." |
+| `400` platform not running | Adapter is stopped | Tell user the platform is not running and suggest `channel enable <platform>`. |
+| `400` no context_token | Token missing | Explain: "The bot has no active session token for this user. Ask the user to send any message to the bot first, then retry." |
+| `503` no known users | Nobody has messaged the bot | Same guidance as empty user list above. |
+| Other error | Unexpected | Show the error message from the response body. |
+
+### Constraints & notes
+
+- **Weixin (iLink protocol)**: Every outbound message requires a `context_token` that is obtained from the most recent inbound message from that user. The token is cached in memory and reset on server restart. If the server was restarted since the user last wrote, the token is gone and the send will fail — the user must message the bot again.
+- **Feishu / WeCom**: No token required. As long as the adapter is running and the `user_id` / `chat_id` is valid, the message will be delivered.
+- This feature is intended for **proactive notifications** (e.g. task completion, reminders). It is not a replacement for the normal reply flow triggered by inbound messages.
+
+---
+
 ## Security
 
 - Always mask secrets in output (last 4 chars only).

data/lib/clacky/server/channel/adapters/weixin/adapter.rb

@@ -393,6 +393,13 @@ module Clacky
             @ctx_mutex.synchronize { @context_tokens[user_id] }
           end
 
+          # Return all user IDs for which we have a cached context_token.
+          # Used by ChannelManager#known_users so callers can enumerate
+          # users reachable for proactive messaging.
+          def context_token_user_ids
+            @ctx_mutex.synchronize { @context_tokens.keys.dup }
+          end
+
           # Split text into ≤2000 Unicode character chunks per iLink protocol recommendation.
           # Priority: split at \n\n, then \n, then space, then hard cut.
           def split_message(text, limit: 2000)

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

@@ -77,6 +77,74 @@ module Clacky
         @mutex.synchronize { @adapters.map(&:platform_id) }
       end
 
+      # Proactively send a message to a user on the given platform.
+      #
+      # For Weixin (iLink protocol) a context_token is required for every outbound
+      # message.  This method looks up the most-recently cached token for user_id.
+      # If no token is found the message cannot be delivered and nil is returned.
+      #
+      # For Feishu and WeCom the chat_id / user_id is sufficient — no token needed.
+      #
+      # @param platform [Symbol, String] e.g. :weixin, :feishu, :wecom
+      # @param user_id  [String]         IM user identifier
+      # @param message  [String]         plain-text (or markdown) message to send
+      # @return [Hash, nil]  adapter result hash, or nil on failure
+      def send_to_user(platform, user_id, message)
+        platform = platform.to_sym
+        adapter  = @mutex.synchronize { @adapters.find { |a| a.platform_id == platform } }
+
+        unless adapter
+          Clacky::Logger.warn("[ChannelManager] send_to_user: no running adapter for :#{platform}")
+          return nil
+        end
+
+        Clacky::Logger.info("[ChannelManager] send_to_user :#{platform} → #{user_id}")
+        adapter.send_text(user_id, message)
+      rescue StandardError => e
+        Clacky::Logger.error("[ChannelManager] send_to_user failed: #{e.message}")
+        nil
+      end
+
+      # Return a list of known user IDs for the given platform.
+      # Collected from every message that has been processed since the server started.
+      # Weixin stores context_tokens keyed by user_id; feishu/wecom track chat_ids
+      # via the session binding table in the registry.
+      #
+      # @param platform [Symbol, String]
+      # @return [Array<String>]
+      def known_users(platform)
+        platform = platform.to_sym
+        adapter  = @mutex.synchronize { @adapters.find { |a| a.platform_id == platform } }
+        return [] unless adapter
+
+        # Weixin adapter exposes @context_tokens whose keys are user_ids
+        if adapter.respond_to?(:context_token_user_ids)
+          return adapter.context_token_user_ids
+        end
+
+        # Fallback: scan session registry for channel_keys matching this platform.
+        # Key formats depend on binding_mode:
+        #   :user       → "platform:user:USER_ID"
+        #   :chat       → "platform:chat:CHAT_ID"
+        #   :chat_user  → "platform:chat:CHAT_ID:user:USER_ID"
+        #
+        # For send_text we need the chat_id (Feishu/WeCom use chat_id as the
+        # receive_id for outbound messages), so we extract the chat portion.
+        prefix = "#{platform}:"
+        ids = []
+        @registry.list.each do |summary|
+          @registry.with_session(summary[:id]) do |s|
+            (s[:channel_keys] || []).each do |key|
+              next unless key.start_with?(prefix)
+
+              remainder = key.sub(prefix, "") # e.g. "chat:OC_ID:user:OU_ID" or "user:UID" or "chat:CID"
+              ids << extract_chat_id(remainder)
+            end
+          end
+        end
+        ids.compact.uniq
+      end
+
       # Hot-reload a single platform adapter with updated config.
       # Stops the existing adapter (if running), then starts a new one if enabled.
       # @param platform [Symbol]
@@ -367,6 +435,29 @@ module Clacky
         end
       end
 
+      # Extract the chat_id from the remainder of a channel_key (after removing "platform:" prefix).
+      #
+      # Possible formats:
+      #   "chat:CHAT_ID:user:USER_ID"  → CHAT_ID  (chat_user mode)
+      #   "chat:CHAT_ID"               → CHAT_ID  (chat mode)
+      #   "user:USER_ID"               → USER_ID  (user mode — use user_id as fallback)
+      #
+      # For Feishu/WeCom send_text, the chat_id is what's needed as receive_id.
+      private def extract_chat_id(remainder)
+        if remainder.start_with?("chat:")
+          # "chat:CHAT_ID:user:USER_ID" or "chat:CHAT_ID"
+          after_chat = remainder.sub("chat:", "")
+          # If there's a ":user:" segment, strip it and everything after
+          idx = after_chat.index(":user:")
+          idx ? after_chat[0...idx] : after_chat
+        elsif remainder.start_with?("user:")
+          # user-only mode: no chat_id available, use user_id
+          remainder.sub("user:", "")
+        else
+          remainder
+        end
+      end
+
       def safe_stop_adapter(adapter)
         adapter.stop
       rescue StandardError => e

data/lib/clacky/server/discover.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "socket"
+
+module Clacky
+  module Server
+    # Discover locally-running Clacky server(s) by scanning PID files
+    # written by Master at /tmp/clacky-master-<port>.pid.
+    #
+    # Used by the CLI (bare `clacky agent` mode) to auto-detect a sibling
+    # server process, so skills that call back into the server (channels,
+    # browser, scheduler, etc.) can work without the user manually setting
+    # CLACKY_SERVER_HOST / CLACKY_SERVER_PORT.
+    #
+    # Fast and side-effect free: only reads files and sends signal 0.
+    # Does NOT probe the TCP port (avoids false positives from stale files
+    # but also avoids noisy connection attempts).
+    module Discover
+      PID_FILE_GLOB = File.join(Dir.tmpdir, "clacky-master-*.pid").freeze
+      PID_FILE_REGEX = /clacky-master-(\d+)\.pid\z/.freeze
+
+      module_function
+
+      # Find the first live Clacky server on this machine.
+      #
+      # @return [Hash, nil] { host: "127.0.0.1", port: Integer, pid: Integer } or nil
+      def find_local
+        find_all_local.first
+      end
+
+      # Find all live Clacky servers on this machine.
+      #
+      # A PID file is considered "live" when:
+      #   1. The filename matches clacky-master-<port>.pid
+      #   2. Its contents parse as a positive integer
+      #   3. Process.kill(0, pid) confirms the PID is alive
+      #
+      # Stale PID files (process gone) are silently ignored. We do NOT
+      # delete them here — that's the owning server's responsibility.
+      #
+      # @return [Array<Hash>] sorted by port ascending
+      def find_all_local
+        Dir.glob(PID_FILE_GLOB).filter_map do |path|
+          m = path.match(PID_FILE_REGEX)
+          next nil unless m
+
+          port = m[1].to_i
+          next nil if port <= 0
+
+          pid_str = File.read(path).strip rescue nil
+          next nil if pid_str.nil? || pid_str.empty?
+
+          pid = pid_str.to_i
+          next nil if pid <= 0
+
+          next nil unless process_alive?(pid)
+
+          { host: "127.0.0.1", port: port, pid: pid }
+        end.sort_by { |e| e[:port] }
+      end
+
+      # @param pid [Integer]
+      # @return [Boolean]
+      def process_alive?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        # ESRCH — no such process; EPERM — process exists but owned by someone else
+        # (still technically alive, but we can't safely assume it's "our" server)
+        false
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/clacky/server/epipe_safe_io.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Clacky
+  module Server
+    # EPIPESafeIO — wraps an IO ($stdout / $stderr) so that writes never raise
+    # Errno::EPIPE / IOError to the calling code.
+    #
+    # Why this exists:
+    #   The server worker process inherits fd 0/1/2 from the Master. If the
+    #   Master itself was launched in a way where its stdout/stderr eventually
+    #   becomes a broken pipe (e.g. launched by an installer that exits, or by
+    #   a GUI/IDE process that closes its end), the worker's first `puts` after
+    #   that pipe breaks raises Errno::EPIPE. Unhandled, this kills the worker
+    #   — taking all in-memory sessions, agent loops, and SSE connections down
+    #   with it, and triggering a crash loop because the new worker inherits
+    #   the same broken fd.
+    #
+    # Behavior:
+    #   - Healthy state: delegates every method to the underlying IO. Users
+    #     see normal terminal output (banner, request logs, etc.).
+    #   - First broken-pipe failure: catches Errno::EPIPE / IOError, swaps
+    #     the underlying IO to /dev/null permanently, and returns silently.
+    #     Subsequent writes succeed (into /dev/null) so the worker stays alive.
+    #   - Session state, agent loops, SSE connections all preserved.
+    #
+    # Scope:
+    #   We only wrap $stdout / $stderr (the global variables that Kernel#puts,
+    #   Kernel#print, Kernel#warn, etc. use under the hood). We do NOT touch
+    #   the STDOUT / STDERR constants — a codebase audit confirmed nothing in
+    #   Clacky writes to those constants directly (only `STDOUT.flush` which
+    #   cannot raise EPIPE).
+    class EPIPESafeIO < SimpleDelegator
+      # Methods that perform writes and may raise Errno::EPIPE.
+      # We override each one to rescue and degrade gracefully.
+      WRITE_METHODS = %i[write write_nonblock syswrite puts print printf << putc].freeze
+
+      WRITE_METHODS.each do |m|
+        define_method(m) do |*args, **kwargs, &blk|
+          if kwargs.empty?
+            __getobj__.public_send(m, *args, &blk)
+          else
+            __getobj__.public_send(m, *args, **kwargs, &blk)
+          end
+        rescue Errno::EPIPE, IOError => e
+          fall_back_to_null!(e)
+          # Retry the write into /dev/null so semantics (return value type) stay
+          # close to what the caller expects. If even this fails, swallow it —
+          # we must not raise from inside a write to $stdout/$stderr.
+          begin
+            if kwargs.empty?
+              __getobj__.public_send(m, *args, &blk)
+            else
+              __getobj__.public_send(m, *args, **kwargs, &blk)
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      # Some callers do `$stdout.flush`. Make it safe too.
+      def flush
+        __getobj__.flush
+      rescue Errno::EPIPE, IOError => e
+        fall_back_to_null!(e)
+        nil
+      end
+
+      # Whether this wrapper has already fallen back to /dev/null.
+      # Useful for tests and diagnostics.
+      def fell_back?
+        @fell_back == true
+      end
+
+      private def fall_back_to_null!(error)
+        return if @fell_back
+
+        @fell_back = true
+        begin
+          # Best-effort: try to log once via Clacky::Logger if available.
+          # Wrapped in rescue because Logger itself might be mid-init.
+          if defined?(Clacky::Logger)
+            Clacky::Logger.warn(
+              "[EPIPESafeIO] Underlying IO broken (#{error.class}: #{error.message}); " \
+              "falling back to /dev/null. Worker stays alive."
+            )
+          end
+        rescue StandardError
+          # ignore
+        end
+
+        begin
+          null = File.open(File::NULL, "w")
+          null.sync = true
+          __setobj__(null)
+        rescue StandardError
+          # If even opening /dev/null fails, leave the original object — at
+          # worst the next write raises again and we rescue again.
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/http_server.rb

@@ -203,15 +203,6 @@ module Clacky
 
         Clacky::Logger.info("[HttpServer PID=#{Process.pid}] start() mode=#{@inherited_socket ? 'worker' : 'standalone'} inherited_socket=#{@inherited_socket.inspect} master_pid=#{@master_pid.inspect}")
 
-        # In standalone mode (no master), kill any stale server and manage our own PID file.
-        # In worker mode the master owns the PID file; we just skip this block.
-        if @inherited_socket.nil?
-          kill_existing_server(@port)
-          pid_file = File.join(Dir.tmpdir, "clacky-server-#{@port}.pid")
-          File.write(pid_file, Process.pid.to_s)
-          at_exit { File.delete(pid_file) if File.exist?(pid_file) }
-        end
-
         # Expose server address and brand name to all child processes (skill scripts, shell commands, etc.)
         # so they can call back into the server without hardcoding the port,
         # and use the correct product name without re-reading brand.yml.
@@ -412,7 +403,13 @@ module Clacky
         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/[^/]+/test$})
+          if method == "POST" && path.match?(%r{^/api/channels/[^/]+/send$})
+            platform = path.sub("/api/channels/", "").sub("/send", "")
+            api_send_channel_message(platform, req, res)
+          elsif method == "GET" && path.match?(%r{^/api/channels/[^/]+/users$})
+            platform = path.sub("/api/channels/", "").sub("/users", "")
+            api_list_channel_users(platform, res)
+          elsif method == "POST" && path.match?(%r{^/api/channels/[^/]+/test$})
             platform = path.sub("/api/channels/", "").sub("/test", "")
             api_test_channel(platform, req, res)
           elsif method == "POST" && path.start_with?("/api/channels/")
@@ -1439,6 +1436,79 @@ module Clacky
         json_response(res, 200, { channels: platforms })
       end
 
+      # POST /api/channels/:platform/send
+      # Proactively send a message to a user via the given IM platform.
+      #
+      # Body:
+      #   { "message": "hello",            # required
+      #     "user_id": "some_user_id" }    # optional — defaults to most-recently active user
+      #
+      # Response:
+      #   200 { ok: true }
+      #   400 { ok: false, error: "..." }  — missing/invalid params or platform not running
+      #   503 { ok: false, error: "..." }  — no known users (nobody has messaged the bot yet)
+      #
+      # Constraints:
+      #   - The platform adapter must be running (channel must be enabled + connected).
+      #   - For Weixin (iLink protocol), a context_token is required per message. This is
+      #     automatically looked up from the in-memory cache populated by inbound messages.
+      #     If no token exists for the target user (i.e. the user has never messaged the bot
+      #     in this server session), the message cannot be delivered.
+      def api_send_channel_message(platform, req, res)
+        platform = platform.to_sym
+        body     = parse_json_body(req)
+        message  = body["message"].to_s.strip
+
+        if message.empty?
+          json_response(res, 400, { ok: false, error: "message is required" })
+          return
+        end
+
+        # Resolve target user_id
+        user_id = body["user_id"].to_s.strip
+        if user_id.empty?
+          # Default to the most-recently active user for this platform
+          known = @channel_manager.known_users(platform)
+          if known.empty?
+            json_response(res, 503, {
+              ok:    false,
+              error: "No known users for :#{platform}. The user must send a message to the bot first."
+            })
+            return
+          end
+          user_id = known.last
+        end
+
+        result = @channel_manager.send_to_user(platform, user_id, message)
+        if result.nil?
+          json_response(res, 400, {
+            ok:    false,
+            error: "Failed to send message. The :#{platform} adapter may not be running, or no context_token is available for user #{user_id}."
+          })
+        else
+          json_response(res, 200, { ok: true, platform: platform, user_id: user_id })
+        end
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
+      # GET /api/channels/:platform/users
+      # Returns the list of known user IDs for the given platform.
+      # These are users who have sent at least one message to the bot in this server session.
+      #
+      # For Weixin: returns users with a cached context_token (required for proactive messaging).
+      # For Feishu / WeCom: returns user IDs extracted from channel session bindings.
+      #
+      # Response:
+      #   200 { users: ["uid1", "uid2", ...] }
+      def api_list_channel_users(platform, res)
+        platform = platform.to_sym
+        users    = @channel_manager.known_users(platform)
+        json_response(res, 200, { platform: platform, users: users })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       # POST /api/upload
       # Accepts a multipart/form-data file upload (field name: "file").
       # Runs the file through FileProcessor: saves original + generates structured
@@ -3648,36 +3718,6 @@ module Clacky
         res.body   = "Not Found"
       end
 
-      # Stop any previously running server on the given port via its PID file.
-      private def kill_existing_server(port)
-        pid_file = File.join(Dir.tmpdir, "clacky-server-#{port}.pid")
-        return unless File.exist?(pid_file)
-
-        pid = File.read(pid_file).strip.to_i
-        return if pid <= 0
-        # After exec-restart, the new process inherits the same PID as the old one.
-        # Skip sending TERM to ourselves — we are already the new server.
-        if pid == Process.pid
-          Clacky::Logger.info("[Server] exec-restart detected (PID=#{pid}), skipping self-kill.")
-          return
-        end
-
-        begin
-          Process.kill("TERM", pid)
-          Clacky::Logger.info("[Server] Stopped existing server (PID=#{pid}) on port #{port}.")
-          puts "Stopped existing server (PID: #{pid}) on port #{port}."
-          # Give it a moment to release the port
-          sleep 0.5
-        rescue Errno::ESRCH
-          Clacky::Logger.info("[Server] Existing server PID=#{pid} already gone.")
-        rescue Errno::EPERM
-          Clacky::Logger.warn("[Server] Could not stop existing server (PID=#{pid}) — permission denied.")
-          puts "Could not stop existing server (PID: #{pid}) — permission denied."
-        ensure
-          File.delete(pid_file) if File.exist?(pid_file)
-        end
-      end
-
       # ── Inner classes ─────────────────────────────────────────────────────────
 
       # Wraps a raw TCP socket, providing thread-safe WebSocket frame sending.

data/lib/clacky/server/server_master.rb

@@ -143,10 +143,16 @@ module Clacky
 
         Clacky::Logger.info("[Master PID=#{Process.pid}] spawn: #{ruby} #{script} #{worker_argv.join(' ')}")
         Clacky::Logger.info("[Master PID=#{Process.pid}] env: #{env.inspect}")
+
         # pgroup: 0 puts worker in its own process group.
         # This lets Master send TERM/KILL to the entire group (-pid) on shutdown,
         # ensuring grandchildren (e.g. chrome-devtools-mcp node process) are also
         # cleaned up even if the worker is force-killed before its shutdown_proc runs.
+        #
+        # NOTE on stdio: we deliberately let the worker inherit Master's fd 0/1/2
+        # so users see startup banner / request logs in their terminal. Protection
+        # against Errno::EPIPE on broken parent stdout is installed inside the
+        # worker itself (see cli.rb worker entry — EPIPESafeIO wrapper).
         pid = spawn(env, ruby, script, *worker_argv, pgroup: 0)
         Clacky::Logger.info("[Master PID=#{Process.pid}] Spawned worker PID=#{pid} pgroup=#{pid}")
         pid

data/lib/clacky/skill.rb

@@ -287,6 +287,36 @@ module Clacky
         end
       end
 
+      # Environment hint: if the skill references ${CLACKY_SERVER_HOST/PORT} but
+      # those vars were not injected (bare-CLI mode without a running server),
+      # the `${...}` placeholders will survive expansion as literal text. In that
+      # case append a non-fatal note so the LLM knows the skill's HTTP callbacks
+      # will not work, without blocking the skill entirely (the user may still
+      # want to read instructions, explore files, etc.).
+      if processed_content.match?(/\$\{CLACKY_SERVER_(HOST|PORT)\}/)
+        processed_content += <<~HINT
+
+
+          ---
+
+          > ⚠️ **Environment note (auto-injected)**: this skill calls back into the
+          > Clacky HTTP server (via `${CLACKY_SERVER_HOST}` / `${CLACKY_SERVER_PORT}`),
+          > but those variables are **not set** in the current process. That means
+          > no local Clacky server was detected.
+          >
+          > Any `curl http://${CLACKY_SERVER_HOST}:...` command in the steps above
+          > will fail with a DNS/connection error. Before running those steps you
+          > should either:
+          >
+          > 1. Ask the user to start the server in another terminal: `clacky server`
+          >    (then retry — the CLI auto-detects it via `/tmp/clacky-master-*.pid`), or
+          > 2. If the task can be completed without the server API, skip those steps
+          >    and tell the user which parts require the server.
+          >
+          > This is an informational hint, not an error. Proceed with judgment.
+        HINT
+      end
+
       processed_content
     end
 

data/lib/clacky/version.rb

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