openclaw-watcher 0.0.1

package/prompts/fix-openclaw.md

@@ -0,0 +1,202 @@
+# OpenClaw Gateway Auto-Fix Agent
+
+## Your Role
+
+You are a professional OpenClaw Gateway troubleshooting and repair expert. When OpenClaw Gateway encounters issues, you need to:
+
+1. **Diagnose the problem**: Analyze error logs and context to identify the root cause
+2. **Fix it completely**: Use all available tools to directly fix the issue, don't just provide suggestions
+3. **Verify the fix**: Ensure the problem is truly resolved
+4. **Standardized summary**: Summarize the repair process in a standard format
+
+## Workflow
+
+### 1. Diagnosis Phase
+
+- Read the provided error information and context
+- Read relevant configuration files
+- Use web search or other tools when necessary
+- Check log files
+- Analyze the root cause
+
+### 2. Repair Phase
+
+**IMPORTANT: Execute fixes directly, don't just give suggestions!**
+
+- Use `Read` tool to read configuration files
+- Use `Edit` or `Write` tool to modify configurations
+- Use `Bash` tool to execute necessary commands
+- If one attempt fails, continue iterating until the problem is resolved
+
+### 3. Verification Phase
+
+- Restart OpenClaw Gateway
+- Check if it starts successfully
+- Verify configuration is loaded correctly
+- Confirm the issue is completely resolved
+
+### 4. Summary Phase
+
+After completion, output a summary in JSON format, **MUST be enclosed between `===FIX_SUMMARY_START===` and `===FIX_SUMMARY_END===` markers**:
+
+```
+===FIX_SUMMARY_START===
+{
+  "issue": "Brief description of the problem",
+  "rootCause": "Root cause analysis",
+  "fixApplied": "Actual repair measures taken (concise description)",
+  "filesModified": ["Modified file paths"],
+  "commandsExecuted": ["Key commands executed"],
+  "verificationResult": "Verification result description",
+  "success": true
+}
+===FIX_SUMMARY_END===
+```
+
+## Common Problem Repair Guide
+
+### Configuration File Errors
+
+**Symptoms**: Gateway fails to start, reports configuration parsing error
+
+**Diagnosis**:
+```bash
+openclaw gateway restart
+# Check error output
+```
+
+**Repair**:
+1. Read the configuration file
+2. Locate the incorrect configuration item
+3. Correct to the proper value
+4. Restart and verify
+
+### Port Conflict
+
+**Symptoms**: Gateway fails to start, reports port already in use
+
+**Diagnosis**:
+```bash
+lsof -i :10002
+netstat -an | grep 10002
+```
+
+**Repair**:
+1. Modify the port in configuration file
+2. Or terminate the process occupying the port
+3. Restart and verify
+
+### Dependency Service Unavailable
+
+**Symptoms**: Gateway cannot connect to database, Redis, etc.
+
+**Diagnosis**:
+```bash
+# Check service status
+systemctl status mongodb
+systemctl status redis
+```
+
+**Repair**:
+1. Start the dependency service
+2. Check connection address in configuration
+3. Correct connection configuration
+4. Restart and verify
+
+### Permission Issues
+
+**Symptoms**: Gateway cannot read/write files
+
+**Diagnosis**:
+```bash
+ls -la /path/to/files
+# Check file permissions
+```
+
+**Repair**:
+```bash
+chmod 755 /path/to/dir
+chown openclaw:openclaw /path/to/files
+```
+
+### Missing Configuration
+
+**Symptoms**: Gateway fails to start, missing required configuration
+
+**Repair**:
+1. Read the configuration file
+2. Add missing configuration items (use reasonable defaults)
+3. Restart and verify
+
+## Important Constraints
+
+1. **MUST fix completely**: Don't just diagnose, must actually fix
+2. **MUST verify**: Must verify success after fixing
+3. **MUST summarize**: Must output standard JSON summary when complete
+4. **Safety first**: Backup before modifying configuration (use `cp` command)
+5. **Minimal changes**: Only modify necessary parts, don't refactor entire config
+6. **Preserve comments**: Preserve original comments when editing config files
+
+## Example Interaction
+
+**Input**:
+```
+Error: Gateway failed to start
+Context:
+Gateway Status Error:
+Error: Cannot parse config file: Unexpected token
+
+Restart Error:
+Failed to start gateway: Invalid JSON syntax in openclaw.json
+```
+
+**Your Actions**:
+
+1. Read the configuration file:
+```bash
+Read ~/.openclaw/openclaw.json
+```
+
+2. Identify the problem: JSON syntax error at line 15
+
+3. Backup configuration:
+```bash
+cp ~/.openclaw/openclaw.json ~/.openclaw/openclaw.json.backup
+```
+
+4. Fix configuration:
+```bash
+Edit openclaw.json, correct syntax error at line 15
+```
+
+5. Restart and verify:
+```bash
+openclaw gateway restart
+openclaw gateway status
+```
+
+6. Output summary:
+```
+===FIX_SUMMARY_START===
+{
+  "issue": "Gateway failed to start - JSON configuration file syntax error",
+  "rootCause": "openclaw.json line 15 has incorrect JSON syntax, causing parse failure",
+  "fixApplied": "Corrected JSON syntax at line 15 in openclaw.json (added missing comma)",
+  "filesModified": ["~/.openclaw/openclaw.json"],
+  "commandsExecuted": ["openclaw gateway restart"],
+  "verificationResult": "Gateway successfully restarted, status check normal, configuration loaded correctly",
+  "success": true
+}
+===FIX_SUMMARY_END===
+```
+
+## Start Working
+
+Upon receiving a problem, immediately begin diagnosis and repair. Remember:
+
+- ✅ Fix it directly
+- ✅ Iterate until successful
+- ✅ Verify the results
+- ✅ Output standard summary
+- ❌ Don't just give suggestions
+- ❌ Don't leave half-finished work

package/scripts/setup.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+
+set -e
+
+echo "🚀 Setting up OpenClaw HealthCheck..."
+
+# Check Node.js version
+echo "Checking Node.js version..."
+NODE_VERSION=$(node -v | cut -d'v' -f2 | cut -d'.' -f1)
+if [ "$NODE_VERSION" -lt 22 ]; then
+    echo "❌ Node.js version 22 or higher is required"
+    echo "Current version: $(node -v)"
+    exit 1
+fi
+echo "✅ Node.js version: $(node -v)"
+
+# Check pnpm
+echo "Checking pnpm..."
+if ! command -v pnpm &> /dev/null; then
+    echo "📦 Installing pnpm..."
+    npm install -g pnpm
+fi
+echo "✅ pnpm version: $(pnpm -v)"
+
+# Install dependencies
+echo "📦 Installing dependencies..."
+pnpm install
+
+# Setup environment
+if [ ! -f .env ]; then
+    echo "📝 Creating .env file..."
+    cp .env.example .env
+    echo "⚠️  Please edit .env file with your configuration"
+else
+    echo "✅ .env file already exists"
+fi
+
+# Create necessary directories
+echo "📁 Creating directories..."
+mkdir -p logs config-backups
+
+# Set executable permissions
+echo "🔐 Setting permissions..."
+chmod +x build.sh
+chmod +x scripts/*.sh 2>/dev/null || true
+
+# Check OpenClaw
+echo "Checking OpenClaw installation..."
+if command -v openclaw &> /dev/null; then
+    echo "✅ OpenClaw found: $(which openclaw)"
+    OPENCLAW_VERSION=$(openclaw version 2>/dev/null || echo "unknown")
+    echo "   Version: $OPENCLAW_VERSION"
+else
+    echo "⚠️  OpenClaw not found in PATH"
+    echo "   Please ensure OpenClaw is installed and accessible"
+fi
+
+# Check AI providers
+echo "Checking AI providers..."
+CLAUDE_FOUND=false
+KIMI_FOUND=false
+
+if command -v claude &> /dev/null; then
+    echo "✅ Claude Code CLI found: $(which claude)"
+    CLAUDE_FOUND=true
+else
+    echo "⚠️  Claude Code CLI not found"
+fi
+
+if command -v kimi &> /dev/null; then
+    echo "✅ Kimi Code CLI found: $(which kimi)"
+    KIMI_FOUND=true
+else
+    echo "⚠️  Kimi Code CLI not found"
+fi
+
+if [ "$CLAUDE_FOUND" = false ] && [ "$KIMI_FOUND" = false ]; then
+    echo ""
+    echo "❌ ERROR: No AI CLI tool found!"
+    echo "   You must install at least one:"
+    echo "   - Claude Code CLI: https://github.com/anthropics/claude-code"
+    echo "   - Kimi Code CLI: https://platform.moonshot.cn/docs/code"
+    echo ""
+    exit 1
+fi
+
+echo ""
+echo "✅ Setup completed!"
+echo ""
+echo "Next steps:"
+echo "1. Edit .env file with your configuration:"
+echo "   vim .env"
+echo ""
+echo "2. Update these important settings:"
+echo "   - OPENCLAW_GATEWAY_URL"
+echo "   - OPENCLAW_CONFIG_PATH"
+echo "   - AI_PROVIDER and API keys"
+echo ""
+echo "3. Run in development mode:"
+echo "   pnpm run dev"
+echo ""
+echo "4. Or build and run in production:"
+echo "   ./build.sh"
+echo "   pnpm start"
+echo ""

package/src/ai/ai-orchestrator.ts

@@ -0,0 +1,95 @@
+import { CLIClient, AIProvider } from './cli-client.js';
+import logger from '@/utils/logger.js';
+import { AIClientConfig, DiagnosisResult, RecoveryConfig } from '@/types';
+
+export class AIOrchestrator {
+  private primaryClient: CLIClient;
+  private fallbackClient?: CLIClient;
+  private configPath: string;
+
+  constructor(aiConfig: AIClientConfig, recoveryConfig: RecoveryConfig) {
+    this.configPath = recoveryConfig.openclawConfigPath;
+
+    // Primary AI client
+    this.primaryClient = new CLIClient(aiConfig.provider as AIProvider, aiConfig.timeout);
+
+    // Fallback to alternative provider
+    const fallbackProvider: AIProvider = aiConfig.provider === 'claude' ? 'kimi' : 'claude';
+    this.fallbackClient = new CLIClient(fallbackProvider, aiConfig.timeout);
+  }
+
+  async initialize(): Promise<void> {
+    logger.info('Initializing AI orchestrator');
+
+    try {
+      await this.primaryClient.initialize();
+      logger.info('Primary AI client initialized');
+    } catch (error: any) {
+      logger.error('Failed to initialize primary AI client', {
+        error: error.message,
+      });
+      throw error;
+    }
+
+    // Try to initialize fallback
+    try {
+      if (this.fallbackClient) {
+        await this.fallbackClient.initialize();
+        logger.info('Fallback AI client initialized');
+      }
+    } catch (error: any) {
+      logger.warn('Failed to initialize fallback AI client', {
+        error: error.message,
+      });
+      // Non-critical, continue
+    }
+  }
+
+  async diagnoseAndFix(error: string): Promise<DiagnosisResult> {
+    try {
+      // Check if primary client is available
+      const isPrimaryAvailable = await this.primaryClient.testConnection();
+
+      if (isPrimaryAvailable) {
+        return await this.primaryClient.diagnoseAndFix(error, this.configPath);
+      } else {
+        logger.warn('Primary AI CLI not available, trying fallback');
+        return await this.fallbackDiagnosis(error);
+      }
+    } catch (primaryError: any) {
+      logger.error('Primary AI diagnosis and fix failed, attempting fallback', {
+        error: primaryError.message,
+      });
+
+      return await this.fallbackDiagnosis(error);
+    }
+  }
+
+  private async fallbackDiagnosis(error: string): Promise<DiagnosisResult> {
+    if (!this.fallbackClient) {
+      throw new Error('No fallback AI client available');
+    }
+
+    try {
+      const isFallbackAvailable = await this.fallbackClient.testConnection();
+
+      if (!isFallbackAvailable) {
+        throw new Error('Fallback AI CLI not available');
+      }
+
+      logger.info('Using fallback AI for diagnosis and fix');
+      return await this.fallbackClient.diagnoseAndFix(error, this.configPath);
+    } catch (fallbackError: any) {
+      logger.error('Fallback AI also failed', { error: fallbackError.message });
+
+      // Return basic diagnosis if all else fails
+      return {
+        issue: 'AI diagnosis and fix unavailable',
+        rootCause: `All AI providers failed. Manual intervention required.`,
+        suggestedFix: 'Attempt basic restart and check logs manually',
+        commands: ['openclaw gateway restart', 'openclaw gateway status'],
+        confidence: 0.1,
+      };
+    }
+  }
+}

package/src/ai/cli-client.ts

@@ -0,0 +1,296 @@
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import logger from '@/utils/logger.js';
+import { DiagnosisResult } from '@/types';
+import { executor } from '@/utils/executor.js';
+
+const execAsync = promisify(exec);
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+interface FixSummary {
+  issue: string;
+  rootCause: string;
+  fixApplied: string;
+  filesModified: string[];
+  commandsExecuted: string[];
+  verificationResult: string;
+  success: boolean;
+  confidence: number;
+}
+
+export type AIProvider = 'claude' | 'kimi';
+
+export class CLIClient {
+  private provider: AIProvider;
+  private timeout: number;
+  private systemPrompt: string = '';
+
+  constructor(provider: AIProvider, timeout: number = 300000) {
+    this.provider = provider;
+    this.timeout = timeout;
+  }
+
+  async initialize(): Promise<void> {
+    const promptPath = path.join(__dirname, '../../prompts/fix-openclaw.md');
+    try {
+      this.systemPrompt = await fs.readFile(promptPath, 'utf-8');
+      logger.info('System prompt loaded', { provider: this.provider });
+    } catch (error: any) {
+      logger.error('Failed to load system prompt', { error: error.message });
+      throw error;
+    }
+  }
+
+  async diagnoseAndFix(error: string, configPath: string): Promise<DiagnosisResult> {
+    logger.info('Starting AI-powered diagnosis and fix', {
+      provider: this.provider,
+      configPath,
+    });
+
+    try {
+      // Gather context
+      const context = await this.gatherContext(error);
+
+      // Create task description
+      const taskDescription = this.createTaskDescription(error, context, configPath);
+
+      // Execute AI CLI
+      const output = await this.executeAICLI(taskDescription, configPath);
+
+      // Parse fix summary
+      const summary = this.parseFixSummary(output);
+
+      // Convert to DiagnosisResult format
+      const diagnosis = this.convertToDiagnosisResult(summary);
+
+      logger.info('AI diagnosis and fix completed', diagnosis);
+      return diagnosis;
+    } catch (error: any) {
+      logger.error('AI diagnosis and fix failed', { error: error.message });
+      throw error;
+    }
+  }
+
+  private async gatherContext(_error: string): Promise<string> {
+    const parts: string[] = [];
+
+    // Get gateway status
+    const statusResult = await executor.getGatewayStatus();
+    if (statusResult.stdout) {
+      parts.push(`Gateway Status:\n${statusResult.stdout}`);
+    }
+    if (statusResult.stderr) {
+      parts.push(`Gateway Status Error:\n${statusResult.stderr}`);
+    }
+
+    // Get recent logs
+    const logsResult = await executor.getGatewayLogs(50);
+    if (logsResult.stdout) {
+      parts.push(`Recent Logs:\n${logsResult.stdout}`);
+    }
+
+    // Attempt restart to get detailed error
+    const restartResult = await executor.restartGateway();
+    if (restartResult.stderr) {
+      parts.push(`Restart Error:\n${restartResult.stderr}`);
+    }
+    if (restartResult.stdout) {
+      parts.push(`Restart Output:\n${restartResult.stdout}`);
+    }
+
+    return parts.join('\n\n');
+  }
+
+  private createTaskDescription(
+    error: string,
+    context: string,
+    configPath: string
+  ): string {
+    return `${this.systemPrompt}
+
+---
+
+## 当前问题
+
+**错误信息**: ${error}
+
+**OpenClaw 配置路径**: ${configPath}
+
+**上下文信息**:
+${context}
+
+---
+
+请立即开始诊断和修复这个问题。记住：
+
+1. 直接修复，不要只给建议
+2. 使用工具读取、编辑配置文件
+3. 执行必要的命令
+4. 验证修复是否成功
+5. 完成后输出标准格式的 JSON 摘要
+
+开始工作！`;
+  }
+
+  private async executeAICLI(task: string, workingDir: string): Promise<string> {
+    const cliCommand = this.provider === 'claude' ? 'claude' : 'kimi';
+
+    logger.info('Executing AI CLI', {
+      provider: this.provider,
+      workingDir,
+    });
+
+    return new Promise<string>((resolve, reject) => {
+      const child = spawn(cliCommand, ['--dangerously-skip-permissions'], {
+        cwd: workingDir,
+        env: {
+          ...process.env,
+          FORCE_COLOR: '0',
+        },
+      });
+
+      const stdoutChunks: Buffer[] = [];
+      const stderrChunks: Buffer[] = [];
+      let settled = false;
+
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          child.kill('SIGTERM');
+          reject(new Error(`${this.provider} CLI timed out after ${this.timeout}ms`));
+        }
+      }, this.timeout);
+
+      child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
+      child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+
+      child.on('error', (err) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          reject(new Error(`${this.provider} CLI spawn error: ${err.message}`));
+        }
+      });
+
+      child.on('close', (code) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          const stdout = Buffer.concat(stdoutChunks).toString();
+          const stderr = Buffer.concat(stderrChunks).toString();
+          const output = stdout + stderr;
+
+          if (code !== 0) {
+            logger.error('AI CLI execution failed', {
+              exitCode: code,
+              stderrPreview: stderr.substring(0, 200),
+            });
+            reject(new Error(`${this.provider} CLI exited with code ${code}`));
+            return;
+          }
+
+          logger.info('AI CLI execution completed', {
+            outputLength: output.length,
+            hasStderr: !!stderr,
+          });
+          resolve(output);
+        }
+      });
+
+      // Pipe task via stdin instead of embedding in command
+      child.stdin.write(task);
+      child.stdin.end();
+    });
+  }
+
+  private parseFixSummary(output: string): FixSummary {
+    try {
+      // Extract JSON summary between markers
+      const startMarker = '===FIX_SUMMARY_START===';
+      const endMarker = '===FIX_SUMMARY_END===';
+
+      const startIndex = output.indexOf(startMarker);
+      const endIndex = output.indexOf(endMarker);
+
+      if (startIndex === -1 || endIndex === -1) {
+        throw new Error('Fix summary markers not found in AI output');
+      }
+
+      const jsonStr = output
+        .substring(startIndex + startMarker.length, endIndex)
+        .trim();
+
+      // Remove markdown code blocks if present
+      const cleanJson = jsonStr.replace(/^```json\n?/, '').replace(/\n?```$/, '');
+
+      const summary: FixSummary = JSON.parse(cleanJson);
+
+      // Validate required fields
+      if (
+        !summary.issue ||
+        !summary.rootCause ||
+        !summary.fixApplied ||
+        typeof summary.success !== 'boolean'
+      ) {
+        throw new Error('Fix summary missing required fields');
+      }
+
+      logger.info('Fix summary parsed successfully', { success: summary.success });
+      return summary;
+    } catch (error: any) {
+      logger.error('Failed to parse fix summary', {
+        error: error.message,
+        outputPreview: output.substring(0, 500),
+      });
+
+      // Return a fallback summary
+      return {
+        issue: 'Parse error',
+        rootCause: `Failed to parse AI output: ${error.message}`,
+        fixApplied: 'AI attempted fixes but summary parsing failed',
+        filesModified: [],
+        commandsExecuted: [],
+        verificationResult: 'Unknown - could not parse verification result',
+        success: false,
+        confidence: 0.3,
+      };
+    }
+  }
+
+  private convertToDiagnosisResult(summary: FixSummary): DiagnosisResult {
+    return {
+      issue: summary.issue,
+      rootCause: summary.rootCause,
+      suggestedFix: summary.fixApplied,
+      commands: summary.commandsExecuted,
+      configChanges: summary.filesModified.map((file) => ({
+        file,
+        path: 'auto-modified',
+        oldValue: 'see git diff',
+        newValue: 'see git diff',
+        reason: summary.fixApplied,
+      })),
+      confidence: summary.confidence,
+    };
+  }
+
+  async testConnection(): Promise<boolean> {
+    try {
+      const command =
+        this.provider === 'claude' ? 'claude --version' : 'kimi --version';
+
+      await execAsync(command, { timeout: 5000 });
+      logger.info(`${this.provider} CLI is available`);
+      return true;
+    } catch (error: any) {
+      logger.warn(`${this.provider} CLI is not available`, {
+        error: error.message,
+      });
+      return false;
+    }
+  }
+}