openclacky 0.9.28 → 0.9.30

data/lib/clacky/client.rb

@@ -51,6 +51,7 @@ module Clacky
     rescue Faraday::Error => e
       { success: false, error: "Connection error: #{e.message}" }
     rescue => e
+      Clacky::Logger.error("[test_connection] #{e.class}: #{e.message}", error: e)
       { success: false, error: e.message }
     end
 
@@ -113,12 +114,25 @@ module Clacky
 
     # ── Prompt-caching support ────────────────────────────────────────────────
 
-    # Returns true for Claude 3.5+ models that support prompt caching.
+    # Returns true for Claude models that support prompt caching (gen 3.5+ or gen 4+).
+    #
+    # Handles both direct model names (e.g. "claude-haiku-4-5") and
+    # Clacky AI Bedrock proxy names with "abs-" prefix (e.g. "abs-claude-haiku-4-5").
+    #
+    # Why only Claude models:
+    #   - MiniMax uses automatic server-side caching (no cache_control needed from client)
+    #   - Kimi uses a proprietary prompt_cache_key param, not cache_control
+    #   - MiMo has no documented caching API
+    #   - Only Claude (direct, OpenRouter, or ClackyAI Bedrock proxy) consumes our
+    #     cache_control / cachePoint markers
     def supports_prompt_caching?(model)
-      model_str = model.to_s.downcase
+      # Strip ClackyAI Bedrock proxy prefix before matching
+      model_str = model.to_s.downcase.sub(/^abs-/, "")
       return false unless model_str.include?("claude")
 
-      model_str.match?(/claude(?:-3[-.]?[5-9]|-[4-9]|-sonnet-[34])/)
+      # Match Claude gen 3.5+ (3.5/3.6/3.7…) or gen 4+ in any name format:
+      #   claude-3.5-sonnet-...  claude-3-7-sonnet  claude-haiku-4-5  claude-sonnet-4-6
+      model_str.match?(/claude(?:-3[-.]?[5-9]|.*-[4-9][-.]|.*-[4-9]$|-[4-9][-.]|-[4-9]$|-sonnet-[34])/)
     end
 
 
@@ -245,7 +259,7 @@ module Clacky
       @bedrock_connection ||= Faraday.new(url: @base_url) do |conn|
         conn.headers["Content-Type"]  = "application/json"
         conn.headers["Authorization"] = "Bearer #{@api_key}"
-        conn.options.timeout      = 120
+        conn.options.timeout      = 300
         conn.options.open_timeout = 10
         conn.ssl.verify           = false
         conn.adapter Faraday.default_adapter
@@ -256,7 +270,7 @@ module Clacky
       @openai_connection ||= Faraday.new(url: @base_url) do |conn|
         conn.headers["Content-Type"]  = "application/json"
         conn.headers["Authorization"] = "Bearer #{@api_key}"
-        conn.options.timeout      = 120
+        conn.options.timeout      = 300
         conn.options.open_timeout = 10
         conn.ssl.verify           = false
         conn.adapter Faraday.default_adapter
@@ -269,7 +283,7 @@ module Clacky
         conn.headers["x-api-key"]      = @api_key
         conn.headers["anthropic-version"] = "2023-06-01"
         conn.headers["anthropic-dangerous-direct-browser-access"] = "true"
-        conn.options.timeout      = 120
+        conn.options.timeout      = 300
         conn.options.open_timeout = 10
         conn.ssl.verify           = false
         conn.adapter Faraday.default_adapter
@@ -328,7 +342,7 @@ module Clacky
       return raw_body unless error_body.is_a?(Hash)
 
       error_body["upstreamMessage"]&.then { |m| return m unless m.empty? }
-      error_body.dig("error", "message")&.then { |m| return m }
+      error_body.dig("error", "message")&.then { |m| return m } if error_body["error"].is_a?(Hash)
       error_body["message"]&.then             { |m| return m }
       error_body["error"].is_a?(String) ? error_body["error"] : (raw_body.to_s[0..200] + (raw_body.to_s.length > 200 ? "..." : ""))
     end

data/lib/clacky/cloud_project_client.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Clacky
+  # CloudProjectClient - Manages cloud project lifecycle via the OpenClacky API
+  #
+  # Handles creating projects, fetching project details (including subscription
+  # status and categorized_config), and listing projects in a workspace.
+  #
+  # All API calls use the Workspace API Key (clacky_ak_*) from ClackyCloudConfig.
+  #
+  # Usage:
+  #   client = CloudProjectClient.new("clacky_ak_xxx", base_url: "https://api.clacky.ai")
+  #
+  #   # Create a new cloud project
+  #   result = client.create_project(name: "my-app")
+  #   # => { success: true, project: { "id" => "...", "name" => "...", "workspace_id" => "...",
+  #   #        "categorized_config" => { "auth" => {...}, "email" => {...}, ... } } }
+  #
+  #   # Get project details (subscription + categorized_config)
+  #   result = client.get_project("019d41be-...")
+  #   # => { success: true, project: { "id" => "...", "subscription" => { "status" => "PAID" }, ... } }
+  #
+  #   # List all projects in workspace
+  #   result = client.list_projects
+  #   # => { success: true, projects: [ { "id" => "...", "name" => "..." }, ... ] }
+  #
+  # On failure, all methods return: { success: false, error: "..." }
+  class CloudProjectClient
+    PROJECTS_PATH       = "/openclacky/v1/projects"
+    REQUEST_TIMEOUT     = 15  # seconds
+    OPEN_TIMEOUT        = 5   # seconds
+
+    def initialize(workspace_api_key, base_url:)
+      @workspace_api_key = workspace_api_key.to_s.strip
+      @base_url          = base_url.to_s.strip.sub(%r{/+$}, "")
+    end
+
+    # Create a new cloud project with the given name.
+    #
+    # @param name [String] Project name (typically the local directory name)
+    # @return [Hash] { success: true, project: {...} } or { success: false, error: "..." }
+    def create_project(name:)
+      validate_inputs!
+
+      response = connection.post(PROJECTS_PATH) do |req|
+        req.headers["Content-Type"] = "application/json"
+        req.body = JSON.generate({ name: name.to_s.strip })
+      end
+
+      unless response.status == 200
+        error_msg = extract_error(response)
+        return { success: false, error: "HTTP #{response.status}: #{error_msg}" }
+      end
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      { success: true, project: body["data"] }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # Get project details including subscription status and categorized_config.
+    #
+    # @param project_id [String] The cloud project UUID
+    # @return [Hash] { success: true, project: {...} } or { success: false, error: "..." }
+    def get_project(project_id)
+      validate_inputs!
+
+      response = connection.get("#{PROJECTS_PATH}/#{project_id}")
+
+      unless response.status == 200
+        error_msg = extract_error(response)
+        return { success: false, error: "HTTP #{response.status}: #{error_msg}" }
+      end
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      { success: true, project: body["data"] }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    # List all projects in the current workspace.
+    #
+    # @return [Hash] { success: true, projects: [...] } or { success: false, error: "..." }
+    def list_projects
+      validate_inputs!
+
+      response = connection.get(PROJECTS_PATH)
+
+      unless response.status == 200
+        error_msg = extract_error(response)
+        return { success: false, error: "HTTP #{response.status}: #{error_msg}" }
+      end
+
+      body = parse_body(response)
+      return body_error(body) unless success_code?(body)
+
+      projects = body["data"] || []
+      projects = projects["list"] if projects.is_a?(Hash) && projects["list"]
+
+      { success: true, projects: Array(projects) }
+    rescue Faraday::Error => e
+      { success: false, error: "Network error: #{e.message}" }
+    rescue => e
+      { success: false, error: "Unexpected error: #{e.message}" }
+    end
+
+    private def validate_inputs!
+      raise ArgumentError, "workspace_api_key is required" if @workspace_api_key.empty?
+      raise ArgumentError, "base_url is required"          if @base_url.empty?
+    end
+
+    private def connection
+      @connection ||= Faraday.new(url: @base_url) do |f|
+        f.options.timeout      = REQUEST_TIMEOUT
+        f.options.open_timeout = OPEN_TIMEOUT
+        f.headers["Authorization"] = "Bearer #{@workspace_api_key}"
+        f.headers["Accept"]        = "application/json"
+        # Disable SSL verification to avoid OpenSSL certificate path issues
+        # on some macOS environments with system Ruby
+        f.ssl.verify = false
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    # Parse JSON response body.
+    # Returns the parsed Hash on success, or nil if the body is not valid JSON.
+    private def parse_body(response)
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    # The API returns code 0 or 200 to signal success.
+    # Returns false if body is nil (unparseable JSON).
+    private def success_code?(body)
+      return false if body.nil?
+
+      code = body["code"].to_i
+      code == 0 || code == 200
+    end
+
+    # Build a failure hash from a parsed response body (may be nil for non-JSON)
+    private def body_error(body)
+      return { success: false, error: "Invalid JSON response from API" } if body.nil?
+
+      msg = body["message"] || body["msg"] || "Unknown API error (code: #{body["code"]})"
+      { success: false, error: msg }
+    end
+
+    # Extract a human-readable error string from a raw Faraday response
+    private def extract_error(response)
+      parsed = JSON.parse(response.body)
+      parsed["message"] || parsed["msg"] || response.body.to_s[0, 200]
+    rescue
+      response.body.to_s[0, 200]
+    end
+  end
+end

data/lib/clacky/default_agents/base_prompt.md

@@ -10,6 +10,7 @@
 
 - **ALWAYS use `glob` tool to find files — NEVER use shell `find` command for file discovery**
 - Test your changes using the shell tool when appropriate
+- **All operations default to the working directory** (shown in session context)
 
 ## TODO Manager Rules
 

data/lib/clacky/default_parsers/doc_parser.rb

@@ -32,15 +32,15 @@ rescue Errno::ENOENT
   nil # textutil not available (non-macOS)
 end
 
-# Fallback: strings command — extracts printable ASCII sequences
-def try_strings(path)
-  stdout, _stderr, status = Open3.capture3("strings", path)
+# Use antiword to extract text from .doc files (Linux/WSL)
+def try_antiword(path)
+  stdout, _stderr, status = Open3.capture3("antiword", path)
   return nil unless status.success?
-  lines = stdout.lines.select { |l| l.strip.length >= 4 }
-  return nil if lines.size < 3
-  lines.join
+  text = stdout.strip
+  return nil if text.bytesize < MIN_CONTENT_BYTES
+  text
 rescue Errno::ENOENT
-  nil # strings not available
+  nil # antiword not installed
 end
 
 # --- main ---
@@ -57,13 +57,13 @@ unless File.exist?(path)
   exit 1
 end
 
-text = try_textutil(path) || try_strings(path)
+text = try_textutil(path) || try_antiword(path)
 
 if text
   print text
   exit 0
 else
   warn "Could not extract text from .doc file."
-  warn "Tip: on macOS textutil should work. On Linux try: apt install antiword"
+  warn "Tip: on macOS textutil should work. On Linux/WSL try: apt install antiword"
   exit 1
 end

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

@@ -43,6 +43,15 @@ node --version 2>/dev/null
 
 Parse the version. If Node.js is missing or version < 20:
 
+Run the bundled installer to automatically install Node.js:
+```bash
+bash ~/.clacky/scripts/install_browser.sh
+```
+
+If the script exits 0 → Node.js is now installed. Proceed to Step 2.
+
+If the script exits non-zero or doesn't exist:
+
 > ❌ Node.js 20+ is required for browser automation.
 >
 > Please install Node.js from: https://nodejs.org

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

@@ -100,10 +100,27 @@ ruby "SKILL_DIR/feishu_setup.rb"
 - Tell the user: "✅ Feishu channel configured automatically! The channel is ready."
 - **Stop here — do not proceed to manual steps.**
 
-**If exit code is non-0 (or script not found):**
-- Note the failure reason from stdout (the last `❌` line).
-- Tell the user: "Automated setup encountered an issue: `<reason>`. Switching to guided setup..."
-- Continue to Step 2 (manual flow) below.
+**If exit code is non-0:**
+- Check stdout for the error message.
+- **If the error contains "Browser not configured" or "browser tool":**
+  - Tell the user: "The browser tool is not configured yet. Let me help you set it up first..."
+  - Invoke the `browser-setup` skill: `invoke_skill("browser-setup", "setup")`.
+  - After browser-setup completes, tell the user: "Browser is ready! Let me retry the Feishu setup..."
+  - **Retry the script** (same command, same timeout). If it succeeds this time, stop. If it fails again, check the new error and proceed accordingly.
+- **If the error contains "No cookies found" or "Please log in":**
+  - Open Feishu login page using browser tool:
+    ```
+    browser(action="navigate", url="https://open.feishu.cn/app")
+    ```
+  - Tell the user: "I've opened Feishu in your browser. Please log in, then reply 'done'."
+  - Wait for "done".
+  - **Retry the script** (same command, same timeout). Repeat this login-wait-retry loop up to **3 times total**.
+    - If any attempt succeeds (exit code 0), stop — setup is complete.
+    - If an attempt fails with a **different** error (not a login error), break out of the loop and continue to Step 2.
+    - If all 3 attempts fail with login errors, tell the user: "Automated setup was unable to detect a Feishu login after 3 attempts. Switching to guided setup..." and continue to Step 2.
+- **Otherwise (non-login, non-browser error):**
+  - Tell the user: "Automated setup encountered an issue: `<error message>`. Switching to guided setup..."
+  - Continue to Step 2 (manual flow) below.
 
 ---
 

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

@@ -130,6 +130,12 @@ class BrowserSession
     snapshot
   end
 
+  def open(url)
+    @client.call("open", url: url)
+    sleep 2
+    snapshot
+  end
+
   def snapshot(interactive: true, compact: true)
     result = @client.call("snapshot", interactive: interactive, compact: compact)
     result["output"].to_s
@@ -394,7 +400,7 @@ def run_setup(browser, api)
 
   # ── Phase 1: Verify login ────────────────────────────────────────────────
   step "Phase 1 — Verifying Feishu login..."
-  snap = browser.navigate("https://open.feishu.cn/app")
+  snap = browser.open("https://open.feishu.cn/app")
   unless snap.include?("创建企业自建") || snap.include?("Create Custom App") || snap.include?("Create Enterprise")
     fail! "Not logged in to Feishu Open Platform. Please log in to open.feishu.cn in Chrome first, then re-run."
   end
@@ -554,7 +560,7 @@ browser     = BrowserSession.new(tool_client)
 
 # Navigate to Feishu to establish page context
 step "Initializing browser session..."
-browser.navigate("https://open.feishu.cn/app")
+browser.open("https://open.feishu.cn/app")
 sleep 1
 
 # Quick sanity check — verify we have cookies

data/lib/clacky/default_skills/deploy/SKILL.md

@@ -1,14 +1,105 @@
 ---
 name: deploy
-description: Deploy Rails applications to Railway PaaS
+description: Deploy Rails applications to Clacky cloud platform(Railway backend)
 agent: coding
-fork_agent: true
 ---
 
 # Railway Deployment for Rails
 
-Deploy a Rails application to Railway platform.
+Deploy a Rails application to the Clacky cloud platform (Railway backend).
 
-Execute the Rails deployment script located in this skill's `scripts/rails_deploy.rb`.
+## When to invoke
 
-The script validates the environment and runs an 8-step deployment workflow.
+Trigger this skill when the user says:
+- "deploy", "/deploy", "deploy my app", "push to production"
+- "部署", "上线", "发布"
+
+---
+
+## How to run
+
+### Step 1 — Run the deploy script
+
+```bash
+bundle exec ruby <absolute-path-to-this-skill>/scripts/rails_deploy.rb
+```
+
+**Timeout**: set to at least 300 seconds (5 minutes).
+
+The script prints each step as it runs. When it finishes it prints one of:
+
+```
+[DEPLOY] RESULT: SUCCESS (2m 34s)
+[DEPLOY] RESULT: FAILED (45s) — <error message>
+```
+
+### Step 2 — Show the full output to the user
+
+After the script exits, **always show the complete stdout output** to the user
+in a code block or verbatim. The output contains step-by-step logs they need
+to see. Do NOT summarise silently — show everything, then add your summary.
+
+### On success
+After showing the output, report the deployed URL and any useful links.
+
+### On failure
+After showing the output, show the error message and summarise the most
+likely cause in one sentence. Suggest next steps (e.g. fix the error shown,
+then re-run `/deploy`).
+
+---
+
+## What the script does internally
+
+The script runs three phases automatically. Do **not** add any AI reasoning
+steps between phases — the script handles all logic internally.
+
+**Phase 0 — Cloud project binding**
+1. Reads `.clacky/openclacky.yml` for `project_id`
+   - If file is missing → runs inline cloud project creation flow
+     (reuses `new/scripts/cloud_project_init.sh`), writes the file, continues
+   - If `project_id` is blank → hard-fail (corrupted file)
+2. Reads `~/.clacky/clacky_cloud.yml` for `workspace_key`
+   - If missing/empty → hard-fail with guidance to obtain key offline
+3. Calls `GET /openclacky/v1/projects/:id` to verify the project exists
+   - 404 → runs inline cloud project creation flow, continues
+   - Other error → hard-fail
+
+**Phase 1 — Subscription check**
+
+| `subscription.status` | Action |
+|------------------------|--------|
+| `PAID` | ✅ Continue |
+| `FREEZE` | ⚠️ Warn, continue |
+| `SUSPENDED` | ❌ Hard-fail |
+| `null` / `OFF` / `CANCELLED` | Open payment page, poll for activation |
+
+Payment polling: open `https://app.clacky.ai/dashboard/openclacky-project/<id>`
+in browser, poll `GET /openclacky/v1/deploy/payment` every 10 s for up to 180 s.
+
+**Phase 2 — Deployment (8 steps)**
+
+| Step | Action |
+|------|--------|
+| 1 | `POST /deploy/create-task` → get `platform_token`, `platform_project_id`, `deploy_task_id` |
+| 2 | `railway link --project <id> --environment production` |
+| 3 | Inject env vars: Rails defaults + Figaro `config/application.yml` production block + `categorized_config` |
+| 4 | Poll `GET /deploy/services` until DB middleware is `SUCCESS` → inject `DATABASE_URL` reference; call `POST /deploy/bind-domain` |
+| 5 | `railway up --service <name> --detach` → notify backend `"deploying"` |
+| 6 | Poll `GET /deploy/status` every 5 s (max 300 s) until `SUCCESS` or failure |
+| 7 | `railway run bundle exec rails db:migrate`; seed if first deployment |
+| 8 | HTTP health check on deployed URL; notify backend `"success"` |
+
+All `railway` commands receive `RAILWAY_TOKEN` via Ruby `ENV` hash — no
+`clackycli` wrapper is needed.
+
+---
+
+## Important constraints
+
+- **Never** modify source files before deploying.
+- **Never** commit or push changes as part of this skill.
+- **Never** prompt the user for Railway credentials — those come from the
+  Clacky platform (`platform_token` is returned by `create-task`).
+- If `railway` CLI is not installed, hard-fail with install instructions:
+  `npm install -g @railway/cli`