yatfa 1.0.78 → 1.0.80

package/setup/setup-claw-agent.rb

@@ -0,0 +1,494 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Yatfa Claw Agent Setup - Loaded by setup-agent.rb when AGENT_TYPE == "claw"
+#
+# This file contains the completely separate setup flow for claw agents:
+#   - Validates claw-specific environment variables
+#   - Installs OpenClaw gateway via npm
+#   - Configures OpenClaw for Telegram + LLM provider
+#   - Installs yatfa-tools native OpenClaw plugin
+#   - Starts the gateway in tmux
+#
+# Dependencies:
+#   - fetch_llm_credentials! is defined by the parent setup-agent.rb
+#   - Standard library requires (json, fileutils, pathname, etc.) are loaded
+#     by setup-agent.rb before this file is required
+
+def check_env_claw!
+  required = %w[OPENCLAW_TELEGRAM_BOT_TOKEN]
+  missing = required.select { |var| ENV[var].to_s.empty? }
+
+  unless missing.empty?
+    puts "❌ Missing environment variables for claw agent: #{missing.join(', ')}"
+    puts ""
+    puts "Required:"
+    puts "  OPENCLAW_TELEGRAM_BOT_TOKEN  - Telegram bot token for the Pi agent"
+    puts ""
+    puts "Optional:"
+    puts "  OPENCLAW_PORT                - Gateway port (default: 18789)"
+    puts "  OPENCLAW_MODEL               - Model to use (default: from openclaw config)"
+    puts "  OPENCLAW_API_KEY             - API key for the model provider"
+    puts "  OPENCLAW_BASE_URL            - Base URL for the model provider"
+    puts ""
+    puts "Yatfa Integration (optional - enables Pi to interact with Yatfa team):"
+    puts "  YATFA_API_URL                - Yatfa API URL (derived from YATFA_URL)"
+    puts "  YATFA_API_KEY                - API key for yatfa-mcp tools"
+    exit 1
+  end
+
+  # Derive YATFA_API_URL from YATFA_URL if set (optional for claw)
+  if ENV["YATFA_URL"] && !ENV["YATFA_API_URL"]
+    ENV["YATFA_API_URL"] = "#{ENV['YATFA_URL']}/api/v1"
+  end
+
+  puts "✅ Claw environment validated"
+  puts "   Telegram Bot Token: #{ENV['OPENCLAW_TELEGRAM_BOT_TOKEN'][0..10]}..."
+  puts "   Gateway Port: #{ENV['OPENCLAW_PORT'] || 18789}"
+
+  if ENV["YATFA_API_URL"] && ENV["YATFA_API_KEY"]
+    puts "   Yatfa Integration: enabled (#{ENV['YATFA_API_URL']})"
+  else
+    puts "   Yatfa Integration: disabled (set YATFA_API_URL and YATFA_API_KEY to enable)"
+  end
+end
+
+def install_openclaw!
+  puts "📦 Installing OpenClaw gateway..."
+
+  # Ensure Node.js 22+ is available (required by openclaw)
+  node_version = `node --version 2>/dev/null`.strip
+  if node_version.empty?
+    puts "❌ Node.js is not installed. OpenClaw requires Node.js 22+."
+    exit 1
+  end
+
+  node_major = node_version.gsub(/^v/, "").split(".").first.to_i
+  if node_major < 22
+    puts "❌ Node.js #{node_version} is too old. OpenClaw requires Node.js >= 22.14.0."
+    exit 1
+  end
+  puts "   Node.js version: #{node_version}"
+
+  # Install OpenClaw globally (sudo needed in container for global npm dir)
+  install_cmd = "npm install -g openclaw@latest 2>&1"
+  install_cmd = "sudo #{install_cmd}" unless Process.uid == 0
+
+  output = `#{install_cmd} 2>&1`
+  unless $?.success?
+    puts "❌ Failed to install openclaw via npm:"
+    puts output
+    exit 1
+  end
+
+  # Verify installation
+  unless system("which openclaw > /dev/null 2>&1")
+    puts "❌ openclaw command not found after installation"
+    exit 1
+  end
+
+  openclaw_version = `openclaw --version 2>/dev/null`.strip
+  puts "✅ OpenClaw installed (version: #{openclaw_version.empty? ? 'unknown' : openclaw_version})"
+
+  # Fix ownership of ~/.openclaw if sudo created it as root
+  openclaw_dir = File.expand_path("~/.openclaw")
+  if File.exist?(openclaw_dir) && Process.uid != 0
+    system("sudo chown -R #{Process.uid}:#{Process.gid} #{openclaw_dir} 2>/dev/null")
+  end
+end
+
+def setup_openclaw_config!(llm_credentials = nil)
+  config_dir = File.expand_path("~/.openclaw")
+  FileUtils.mkdir_p(config_dir)
+
+  # Ensure config dir is owned by current user (sudo npm install may create it as root)
+  File.chmod(0700, config_dir) if File.exist?(config_dir)
+
+  config_path = File.join(config_dir, "openclaw.json")
+
+  # Build config with correct OpenClaw schema:
+  #   models.providers.<id>.apiKey / baseUrl  — provider credentials
+  #   agents.defaults.model                    — "provider/model" format
+  config = {
+    "gateway" => { "mode" => "local" },
+    "models" => { "providers" => {} },
+    "agents" => { "defaults" => {} },
+    "channels" => {
+      "telegram" => {
+        "botToken" => ENV["OPENCLAW_TELEGRAM_BOT_TOKEN"]
+      }
+    },
+    "plugins" => { "enabled" => true }
+  }
+
+  # Resolve API key, base URL, and model — from backend or env vars
+  api_key = ENV["OPENCLAW_API_KEY"]
+  base_url = ENV["OPENCLAW_BASE_URL"]
+  model = ENV["OPENCLAW_MODEL"]
+
+  if llm_credentials
+    api_key ||= llm_credentials["api_key"]
+    base_url ||= llm_credentials["base_url"] if llm_credentials["base_url"] && !llm_credentials["base_url"].empty?
+    model ||= llm_credentials["model_sonnet"] || llm_credentials["model_opus"] || llm_credentials["model_haiku"]
+  end
+
+  if api_key
+    # Detect API format from base URL (anthropic-messages vs openai-completions)
+    api_format = "openai-completions"
+    if base_url && (base_url.include?("anthropic") || base_url.include?("claude"))
+      api_format = "anthropic-messages"
+    end
+
+    # Register provider with id "yatfa" — requires baseUrl and models array
+    provider_entry = {
+      "apiKey" => api_key,
+      "baseUrl" => base_url || "https://api.anthropic.com",
+      "models" => [
+        {
+          "id" => model || "default",
+          "name" => model || "default",
+          "api" => api_format
+        }
+      ]
+    }
+    config["models"]["providers"]["yatfa"] = provider_entry
+
+    # Prefix model with provider if not already prefixed
+    if model && !model.empty?
+      config["agents"]["defaults"]["model"] = model.include?("/") ? model : "yatfa/#{model}"
+    end
+
+    puts "   Provider: yatfa (#{api_format})"
+    puts "   Backend model: #{model || 'default'}"
+    puts "   Backend base URL: #{base_url || 'default'}"
+  else
+    # No credentials — just set model if provided (uses built-in providers)
+    if model && !model.empty?
+      config["agents"]["defaults"]["model"] = model
+    end
+    puts "   No API key configured — using openclaw defaults"
+  end
+
+  # Remove empty sections
+  config["models"].delete("providers") if config["models"]["providers"].empty?
+  config.delete("models") if config["models"].empty?
+  config["agents"].delete("defaults") if config["agents"]["defaults"].empty?
+  config.delete("agents") if config["agents"].empty?
+
+  # Write config (do not overwrite if file exists and has custom config)
+  if File.exist?(config_path)
+    begin
+      existing = JSON.parse(File.read(config_path))
+      # Backend (new) values win for models/agents; existing wins for everything else
+      config = existing.merge(config) { |key, old_val, new_val|
+        if key == "models" || key == "agents"
+          if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            old_val.merge(new_val) # new (backend) overrides old
+          else
+            new_val
+          end
+        elsif old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          new_val.merge(old_val) # old (user) overrides new
+        else
+          old_val
+        end
+      }
+      puts "📝 Merging with existing OpenClaw config"
+    rescue JSON::ParserError
+      puts "⚠️  Existing openclaw.json is invalid, overwriting"
+    end
+  end
+
+  File.write(config_path, JSON.pretty_generate(config))
+  puts "✅ OpenClaw config written to #{config_path}"
+end
+
+def setup_yatfa_tools_for_claw!
+  # Installs the yatfa-tools native OpenClaw plugin so Pi's main agent session
+  # can use yatfa tools directly (tickets, memories, knowledge, etc.)
+  # Also installs the yatfa-bridge skill for context on how to use them.
+  yatfa_api_url = ENV["YATFA_API_URL"]
+  yatfa_api_key = ENV["YATFA_API_KEY"]
+
+  unless yatfa_api_url && !yatfa_api_url.empty? && yatfa_api_key && !yatfa_api_key.empty?
+    puts "ℹ️  Yatfa integration disabled (YATFA_API_URL or YATFA_API_KEY not set)"
+    return
+  end
+
+  puts "🔗 Setting up Yatfa integration for Pi agent..."
+
+  # Install native OpenClaw plugin to ~/.openclaw/extensions/yatfa-tools/
+  ext_dir = File.expand_path("~/.openclaw/extensions/yatfa-tools")
+  FileUtils.mkdir_p(ext_dir)
+
+  plugin_js = File.join(ext_dir, "index.js")
+  plugin_manifest = File.join(ext_dir, "openclaw.plugin.json")
+  plugin_pkg = File.join(ext_dir, "package.json")
+
+  # Resolve path to the openclaw dist directory for the definePluginEntry import
+  openclaw_dist = nil
+  plugin_entry_file = nil
+  ["/usr/lib/node_modules/openclaw/dist", "/usr/local/lib/node_modules/openclaw/dist"].each do |candidate|
+    next unless File.directory?(candidate)
+    matches = Dir.glob(File.join(candidate, "plugin-entry-*.js"))
+    if matches.any?
+      openclaw_dist = candidate
+      plugin_entry_file = File.basename(matches.first)
+      break
+    end
+  end
+
+  unless openclaw_dist && plugin_entry_file
+    puts "⚠️  Cannot find OpenClaw dist directory — skipping plugin install"
+    return
+  end
+
+  # Compute relative path from ext_dir to openclaw dist for the import
+  rel_path = Pathname.new(openclaw_dist).relative_path_from(Pathname.new(ext_dir))
+
+  # Fetch tool definitions from Rails now (during setup) so the plugin can
+  # register them synchronously — register() must NOT be async.
+  tool_defs_json = File.join(ext_dir, "tools.json")
+  begin
+    uri = URI("#{yatfa_api_url}/mcp/tools")
+    req = Net::HTTP::Get.new(uri)
+    req["Content-Type"] = "application/json"
+    req["X-API-Key"] = yatfa_api_key
+    req["Accept"] = "application/json"
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = uri.scheme == "https"
+    resp = http.request(req)
+    tools_data = JSON.parse(resp.body)
+    File.write(tool_defs_json, JSON.pretty_generate(tools_data["tools"] || []))
+    puts "✅ Fetched #{(tools_data["tools"] || []).length} tool definitions from Yatfa API"
+  rescue => e
+    puts "⚠️  Failed to fetch tool definitions: #{e.message}"
+    File.write(tool_defs_json, "[]")
+  end
+
+  File.write(plugin_js, <<~JS)
+    import { t as definePluginEntry } from "#{rel_path}/#{plugin_entry_file}";
+    import { readFileSync } from "node:fs";
+    import { fileURLToPath } from "node:url";
+    import { dirname, join } from "node:path";
+
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+
+    const API_BASE_URL = #{yatfa_api_url.inspect};
+    const API_KEY = #{yatfa_api_key.inspect};
+
+    const toolDefs = JSON.parse(readFileSync(join(__dirname, "tools.json"), "utf8"));
+
+    export default definePluginEntry({
+      id: "yatfa-tools",
+      name: "Yatfa Tools",
+      description: "Yatfa team management tools — tickets, memories, knowledge, agents, and more.",
+
+      register(api) {
+        for (const def of toolDefs) {
+          api.registerTool({
+            name: def.name,
+            description: def.description,
+            parameters: def.inputSchema || { type: "object", properties: {} },
+            async execute(_id, params) {
+              try {
+                const url = `${API_BASE_URL}/mcp/execute`;
+                const res = await fetch(url, {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    "X-API-Key": API_KEY,
+                    Accept: "application/json",
+                  },
+                  body: JSON.stringify({ tool: def.name, params }),
+                });
+                if (!res.ok) {
+                  const body = await res.text();
+                  return { content: [{ type: "text", text: `API Error ${res.status}: ${body}` }], isError: true };
+                }
+                const data = await res.json();
+                return { content: [{ type: "text", text: JSON.stringify(data.result, null, 2) }] };
+              } catch (err) {
+                return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+              }
+            },
+          });
+        }
+      },
+    });
+  JS
+
+  File.write(plugin_manifest, <<~JSON)
+    {
+      "id": "yatfa-tools",
+      "name": "Yatfa Tools",
+      "description": "Yatfa team management tools — tickets, memories, knowledge, agents, and more.",
+      "configSchema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {}
+      }
+    }
+  JSON
+
+  File.write(plugin_pkg, <<~JSON)
+    {
+      "name": "@yatfa/openclaw-plugin",
+      "version": "1.0.0",
+      "type": "module",
+      "openclaw": {
+        "extensions": ["./index.js"],
+        "compat": { "pluginApi": ">=2026.4.10" }
+      }
+    }
+  JSON
+
+  puts "✅ yatfa-tools plugin installed to #{ext_dir}"
+
+  # Install yatfa-bridge skill
+  skills_dir = File.expand_path("~/.openclaw/skills/yatfa-bridge")
+  FileUtils.mkdir_p(skills_dir)
+
+  skill_content = <<~SKILL
+    # Yatfa Bridge - Pi Agent Integration
+
+    You have access to the Yatfa team's task management system. You are the human's **front desk** to the Yatfa agent team.
+
+    ## What You Can Do
+
+    Use the yatfa tools to:
+
+    - **Check status**: `get_status` — see project overview, ticket counts, agent availability
+    - **View tickets**: `list_tickets` — see all tickets with optional filters (status, priority)
+    - **Get ticket details**: `get_ticket` — full details of a specific ticket
+    - **Create tickets**: `create_ticket` — create new tasks or bugs
+    - **Add comments**: `add_comment` — add notes, questions, or decisions to tickets
+    - **Search knowledge**: `search_knowledge_articles` — find project documentation
+    - **Read knowledge**: `get_knowledge_article` — read a specific article
+    - **Search tickets**: `search_tickets` — semantically search for related tickets
+    - **Search memories**: `search_memory` — find relevant agent memories
+    - **Store memories**: `store_memory` — persist learnings or context for future reference
+
+    ## How to Help the Human
+
+    When the human messages you on Telegram:
+
+    1. **Status requests**: "What's the team working on?" → Use `get_status` and `list_tickets`
+    2. **Ticket creation**: "Create a task to fix the login bug" → Use `create_ticket`
+    3. **Ticket updates**: "What's the status of TINK-42?" → Use `get_ticket`
+    4. **Questions**: "Why was this rejected?" → Use `get_ticket` and `list_comments`
+    5. **Knowledge**: "What's the deployment process?" → Use `search_knowledge_articles`
+
+    ## Important Guidelines
+
+    - Always confirm with the human before creating tickets (show title and description first)
+    - Use human-friendly language — translate ticket statuses and technical terms
+    - Don't modify or transition tickets — that's the agents' job
+    - If unsure, ask the human for clarification
+    - Keep responses concise for Telegram (avoid overly long messages)
+
+    ## Ticket Statuses
+
+    - **draft/backlog/todo**: Not yet started
+    - **in_progress**: Currently being worked on by a team member
+    - **pending_audit**: Awaiting code review
+    - **pending_approval**: Ready for final approval
+    - **done**: Completed
+    - **blocked**: Something is preventing progress
+  SKILL
+
+  File.write(File.join(skills_dir, "SKILL.md"), skill_content)
+  puts "✅ yatfa-bridge skill installed to #{skills_dir}"
+end
+
+def run_openclaw_gateway!
+  port = ENV["OPENCLAW_PORT"] || "18789"
+
+  # Validate port is numeric to prevent command injection
+  unless port =~ /\A\d+\z/
+    puts "❌ Invalid OPENCLAW_PORT: must be numeric, got '#{port}'"
+    exit 1
+  end
+
+  puts ""
+  puts "🐾 Starting OpenClaw Gateway..."
+  puts "   Port: #{port}"
+  puts "   Press Ctrl+B then D to detach from tmux"
+  puts ""
+
+  # Use tmux for persistent session with status bar
+  # Array form of system() prevents shell injection
+  system("tmux", "new-session", "-d", "-s", "agent", "-x", "220", "-y", "50",
+         "openclaw gateway --port #{port} --verbose",
+         err: File::NULL)
+
+  # Enable mouse mode (scroll, pane selection)
+  system("tmux set-option -t agent mouse on 2>/dev/null")
+
+  # Set up status bar
+  system("tmux set-option -t agent status-position bottom 2>/dev/null")
+  system("tmux set-option -t agent status-style 'bg=#1a1a2e,fg=#e0e0e0' 2>/dev/null")
+  system("tmux set-option -t agent status-left-length 30 2>/dev/null")
+  system("tmux set-option -t agent status-left ' 🐾 OpenClaw Gateway ' 2>/dev/null")
+  system("tmux set-option -t agent status-right ' %Y-%m-%d %H:%M ' 2>/dev/null")
+
+  # Wait for gateway to start, then verify the port is listening
+  sleep 2
+
+  gateway_running = false
+  5.times do |i|
+    begin
+      socket = TCPSocket.new("localhost", port.to_i)
+      socket.close
+      gateway_running = true
+      break
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET
+      sleep 1
+    end
+  end
+
+  if gateway_running
+    puts "✅ OpenClaw gateway started in tmux session 'agent'"
+    puts "   Health check: curl http://localhost:#{port}/healthz"
+  else
+    puts "⚠️  Gateway port not responding after 7 seconds"
+    puts "   Check logs: docker exec <container> tmux capture-pane -t agent -p"
+    # Don't exit - gateway may still be initializing
+  end
+
+  # Block: keep the script alive so the container doesn't restart
+  # The gateway runs inside tmux — periodically check it's still running
+  puts "   Keeping container alive (gateway runs in tmux)..."
+  loop do
+    sleep 60
+    # If tmux session died, exit so the container can restart
+    unless system("tmux has-session -t agent 2>/dev/null")
+      puts "⚠️  tmux session 'agent' died, exiting..."
+      break
+    end
+  end
+end
+
+def setup_claw_agent!
+  puts ""
+  puts "🐾 Yatfa Claw Agent Setup"
+  puts "=========================="
+  puts ""
+
+  check_env_claw!
+  install_openclaw!
+  llm_credentials = fetch_llm_credentials!
+  if llm_credentials
+    puts "✅ Fetched LLM credentials from backend (source: #{llm_credentials['source']})"
+  else
+    puts "⚠️  No LLM credentials from backend — relying on OPENCLAW_* env vars"
+  end
+  setup_openclaw_config!(llm_credentials)
+  setup_yatfa_tools_for_claw!
+  run_openclaw_gateway!
+end
+
+# ─── Main ─────────────────────────────────────────────────────────────────
+
+setup_claw_agent!