openclaw-watcher 0.0.1

package/src/cli.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { startCommand } from './commands/start.js';
+import { statusCommand } from './commands/status.js';
+import { configCommand } from './commands/config.js';
+
+const program = new Command();
+
+program
+  .name('openclaw-watcher')
+  .description('AI-powered automated health monitoring and self-healing for OpenClaw Gateway')
+  .version('2.0.0');
+
+program
+  .command('init')
+  .description('Initialize OpenClaw Watcher with interactive configuration')
+  .option('--no-git', 'Skip Git repository initialization')
+  .action(initCommand);
+
+program
+  .command('start')
+  .description('Start health monitoring and auto-repair service')
+  .option('-d, --daemon', 'Run as daemon process')
+  .action(startCommand);
+
+program
+  .command('status')
+  .description('Show current monitoring status')
+  .action(statusCommand);
+
+program
+  .command('config')
+  .description('Manage configuration')
+  .option('-s, --show', 'Show current configuration')
+  .option('-e, --edit', 'Edit configuration file')
+  .action(configCommand);
+
+program.parse();

package/src/commands/config.ts

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { loadConfig, getConfigFilePath } from '@/setup/config-loader.js';
+import fs from 'fs/promises';
+
+const execAsync = promisify(exec);
+
+interface ConfigOptions {
+  show?: boolean;
+  edit?: boolean;
+}
+
+export async function configCommand(options: ConfigOptions) {
+  const configPath = getConfigFilePath();
+
+  if (options.show) {
+    try {
+      const config = await loadConfig();
+      if (!config) {
+        console.log(chalk.yellow('Configuration not found'));
+        return;
+      }
+
+      console.log(chalk.bold.cyan('\n📋 Current Configuration\n'));
+      console.log(JSON.stringify(config, null, 2));
+      console.log('');
+    } catch (error: any) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  } else if (options.edit) {
+    try {
+      const editor = process.env.EDITOR || 'vim';
+      await execAsync(`${editor} ${configPath}`);
+      console.log(chalk.green('✓ Configuration updated'));
+    } catch (error: any) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  } else {
+    // Show config file path
+    try {
+      await fs.access(configPath);
+      console.log(chalk.cyan('Configuration file:'), chalk.white(configPath));
+      console.log('');
+      console.log(chalk.gray('Use:'));
+      console.log(chalk.white('  --show  '), chalk.gray('Show current configuration'));
+      console.log(chalk.white('  --edit  '), chalk.gray('Edit configuration file'));
+    } catch {
+      console.log(chalk.yellow('Configuration not found'));
+      console.log(
+        chalk.gray('\nRun: npx openclaw-watcher init')
+      );
+    }
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,239 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { ConfigInitializer } from '@/setup/config-initializer.js';
+import { GitInitializer } from '@/setup/git-initializer.js';
+import { SafeConfigGenerator } from '@/setup/safe-config-generator.js';
+import { GitHubCli } from '@/utils/github-cli.js';
+import { getConfigPath } from '@/utils/paths.js';
+
+interface InitOptions {
+  git?: boolean;
+}
+
+export async function initCommand(options: InitOptions) {
+  console.log(
+    boxen(chalk.bold.cyan('OpenClaw Watcher'), {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'cyan',
+    })
+  );
+
+  console.log(chalk.gray('AI-powered health monitoring and auto-repair for OpenClaw Gateway\n'));
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'openclawConfigPath',
+      message: 'OpenClaw configuration directory:',
+      default: path.join(os.homedir(), '.openclaw'),
+      validate: async (input: string) => {
+        const expandedPath = input.replace(/^~/, os.homedir());
+        try {
+          const stats = await fs.stat(expandedPath);
+          if (!stats.isDirectory()) {
+            return 'Path must be a directory';
+          }
+          return true;
+        } catch {
+          return 'Directory does not exist';
+        }
+      },
+    },
+    {
+      type: 'input',
+      name: 'gatewayUrl',
+      message: 'OpenClaw Gateway URL:',
+      default: 'http://localhost:10002',
+      validate: (input: string) => {
+        try {
+          new URL(input);
+          return true;
+        } catch {
+          return 'Please enter a valid URL';
+        }
+      },
+    },
+    {
+      type: 'list',
+      name: 'aiProvider',
+      message: 'AI provider:',
+      choices: [
+        { name: 'Claude Code CLI (Recommended)', value: 'claude' },
+        { name: 'Kimi Code CLI', value: 'kimi' },
+      ],
+      default: 'claude',
+    },
+    {
+      type: 'confirm',
+      name: 'initGit',
+      message: 'Initialize Git repository for config tracking?',
+      default: options.git !== false,
+      when: () => options.git !== false,
+    },
+    {
+      type: 'input',
+      name: 'gitRepoName',
+      message: 'Git repository name:',
+      default: 'openclaw-config',
+      when: (answers: any) => answers.initGit,
+    },
+    {
+      type: 'confirm',
+      name: 'useGitHubCli',
+      message: 'Sync repair history to GitHub? (requires gh CLI)',
+      default: true,
+      when: (answers: any) => answers.initGit,
+    },
+  ]);
+
+  console.log('');
+  const spinner = ora('Initializing configuration...').start();
+
+  try {
+    // Expand paths
+    const openclawConfigPath = answers.openclawConfigPath.replace(/^~/, os.homedir());
+
+    // 1. Create config file
+    spinner.text = 'Creating configuration file...';
+    const configInitializer = new ConfigInitializer();
+    await configInitializer.create({
+      openclawConfigPath,
+      gatewayUrl: answers.gatewayUrl,
+      healthCheckInterval: 30000,
+      failureThreshold: 3,
+      aiProvider: answers.aiProvider,
+      gitTracking: answers.initGit || false,
+      useGitHubCli: answers.useGitHubCli || false,
+    });
+
+    // 2. Initialize Git repository if requested
+    if (answers.initGit) {
+      spinner.text = 'Initializing Git repository...';
+      const gitInitializer = new GitInitializer(openclawConfigPath);
+      await gitInitializer.init({
+        repoName: answers.gitRepoName,
+        isPrivate: true,
+      });
+
+      // 3. Generate safe config
+      spinner.text = 'Generating safe configuration file...';
+      const safeConfigGen = new SafeConfigGenerator(openclawConfigPath);
+      await safeConfigGen.generate();
+
+      // 4. Setup pre-commit hook
+      spinner.text = 'Setting up pre-commit hook...';
+      await gitInitializer.setupPreCommitHook();
+
+      // 5. Initial commit
+      spinner.text = 'Creating initial commit...';
+      await gitInitializer.initialCommit();
+
+      // 6. GitHub sync if requested
+      if (answers.useGitHubCli) {
+        await setupGitHubSync(spinner, answers.gitRepoName, openclawConfigPath);
+      }
+    }
+
+    spinner.succeed(chalk.green('Initialization complete!'));
+
+    console.log('');
+    console.log(
+      boxen(
+        chalk.white.bold('Next Steps:\n\n') +
+          chalk.cyan('1. ') +
+          'Review configuration: ' +
+          chalk.yellow(getConfigPath()) +
+          '\n' +
+          chalk.cyan('2. ') +
+          'Start monitoring: ' +
+          chalk.yellow('npx openclaw-watcher start') +
+          '\n' +
+          chalk.cyan('3. ') +
+          'Check status: ' +
+          chalk.yellow('npx openclaw-watcher status'),
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: 'round',
+          borderColor: 'green',
+        }
+      )
+    );
+
+    if (answers.initGit) {
+      console.log(
+        chalk.gray(`\n📂 Git repository initialized at: ${chalk.white(openclawConfigPath)}`)
+      );
+      console.log(
+        chalk.gray(`   - ${chalk.white('openclaw.safe.json')} is tracked (sensitive data redacted)`)
+      );
+      console.log(chalk.gray(`   - ${chalk.white('openclaw.json')} is ignored (contains secrets)`));
+      if (answers.useGitHubCli) {
+        console.log(
+          chalk.gray(`   - ${chalk.white('GitHub sync')} enabled (auto-push after each repair)`)
+        );
+      }
+    }
+  } catch (error: any) {
+    spinner.fail(chalk.red('Initialization failed'));
+    console.error(chalk.red(`\nError: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+async function setupGitHubSync(spinner: ReturnType<typeof ora>, repoName: string, localPath: string): Promise<void> {
+  const gh = new GitHubCli();
+
+  // Check gh CLI installed
+  spinner.text = 'Checking GitHub CLI...';
+  if (!(await gh.isInstalled())) {
+    spinner.warn(chalk.yellow('GitHub CLI (gh) not found — skipping GitHub sync'));
+    console.log(chalk.gray('  Install: https://cli.github.com'));
+    spinner.start('Continuing initialization...');
+    return;
+  }
+
+  // Check gh auth
+  if (!(await gh.isAuthenticated())) {
+    spinner.stop();
+    console.log(chalk.yellow('\n⚠ GitHub CLI not authenticated.'));
+    console.log(chalk.gray('  Run `gh auth login` in another terminal, then continue.\n'));
+
+    const { retry } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'retry',
+        message: 'Have you completed gh auth login?',
+        default: true,
+      },
+    ]);
+
+    spinner.start('Checking authentication...');
+
+    if (!retry || !(await gh.isAuthenticated())) {
+      spinner.warn(chalk.yellow('GitHub auth not ready — skipping GitHub sync'));
+      spinner.start('Continuing initialization...');
+      return;
+    }
+  }
+
+  // Create repo and push
+  spinner.text = 'Creating GitHub repository...';
+  const result = await gh.createRepoAndPush(repoName, localPath);
+
+  if (result.success) {
+    spinner.succeed(chalk.green(`GitHub repository created: ${repoName}`));
+    spinner.start('Finalizing...');
+  } else {
+    spinner.warn(chalk.yellow(`GitHub repo creation failed — you can set it up later`));
+    console.log(chalk.gray(`  ${result.stderr}`));
+    spinner.start('Continuing initialization...');
+  }
+}

package/src/commands/start.ts

@@ -0,0 +1,75 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig } from '@/setup/config-loader.js';
+import { GatewayMonitor } from '@/healthcheck/gateway-monitor.js';
+import logger from '@/utils/logger.js';
+
+interface StartOptions {
+  daemon?: boolean;
+}
+
+export async function startCommand(_options: StartOptions) {
+  const spinner = ora('Loading configuration...').start();
+
+  try {
+    const config = await loadConfig();
+
+    if (!config) {
+      spinner.fail(chalk.red('Configuration not found'));
+      console.log(
+        chalk.yellow(
+          '\nPlease run initialization first: npx openclaw-watcher init'
+        )
+      );
+      process.exit(1);
+    }
+
+    spinner.text = 'Starting OpenClaw Watcher...';
+
+    const monitor = new GatewayMonitor(
+      config.monitor,
+      config.ai,
+      config.recovery
+    );
+
+    await monitor.start();
+
+    spinner.succeed(chalk.green('OpenClaw Watcher started successfully!'));
+
+    console.log('');
+    console.log(chalk.cyan('📊 Monitoring:'), chalk.white(config.monitor.gatewayUrl));
+    console.log(
+      chalk.cyan('⏱️  Check interval:'),
+      chalk.white(`${config.monitor.checkInterval / 1000}s`)
+    );
+    console.log(
+      chalk.cyan('🚨 Failure threshold:'),
+      chalk.white(config.monitor.failureThreshold)
+    );
+    console.log(chalk.cyan('🤖 AI Provider:'), chalk.white(config.ai.provider));
+    console.log('');
+    console.log(chalk.gray('Press Ctrl+C to stop'));
+
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+      console.log('\n');
+      const stopSpinner = ora('Stopping OpenClaw Watcher...').start();
+      monitor.stop();
+      stopSpinner.succeed(chalk.green('Stopped'));
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', () => {
+      console.log('\n');
+      const stopSpinner = ora('Stopping OpenClaw Watcher...').start();
+      monitor.stop();
+      stopSpinner.succeed(chalk.green('Stopped'));
+      process.exit(0);
+    });
+  } catch (error: any) {
+    spinner.fail(chalk.red('Failed to start'));
+    console.error(chalk.red(`\nError: ${error.message}`));
+    logger.error('Failed to start', { error: error.message });
+    process.exit(1);
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,79 @@
+import chalk from 'chalk';
+import { loadConfig } from '@/setup/config-loader.js';
+import fs from 'fs/promises';
+import { getChangesFilePath } from '@/utils/paths.js';
+
+export async function statusCommand() {
+  try {
+    const config = await loadConfig();
+
+    if (!config) {
+      console.log(chalk.yellow('⚠️  Not initialized'));
+      console.log(
+        chalk.gray('\nRun: npx openclaw-watcher init')
+      );
+      return;
+    }
+
+    console.log(chalk.bold.cyan('\n📊 OpenClaw Watcher Status\n'));
+
+    console.log(chalk.white('Configuration:'));
+    console.log(chalk.gray('  Gateway URL:'), chalk.white(config.monitor.gatewayUrl));
+    console.log(
+      chalk.gray('  Check Interval:'),
+      chalk.white(`${config.monitor.checkInterval / 1000}s`)
+    );
+    console.log(
+      chalk.gray('  Failure Threshold:'),
+      chalk.white(config.monitor.failureThreshold)
+    );
+    console.log(chalk.gray('  AI Provider:'), chalk.white(config.ai.provider));
+    console.log(
+      chalk.gray('  Config Path:'),
+      chalk.white(config.recovery.openclawConfigPath)
+    );
+    console.log(
+      chalk.gray('  Git Tracking:'),
+      config.recovery.useGitTracking ? chalk.green('✓ Enabled') : chalk.gray('✗ Disabled')
+    );
+
+    // Check repair history
+    const changeLogPath = getChangesFilePath();
+    try {
+      const changeLogContent = await fs.readFile(changeLogPath, 'utf-8');
+      const changes = JSON.parse(changeLogContent);
+
+      console.log(chalk.white('\nRepair History:'));
+      console.log(
+        chalk.gray('  Total Repairs:'),
+        chalk.white(changes.length)
+      );
+
+      if (changes.length > 0) {
+        const lastChange = changes[changes.length - 1];
+        console.log(
+          chalk.gray('  Last Repair:'),
+          chalk.white(new Date(lastChange.timestamp).toLocaleString())
+        );
+        console.log(
+          chalk.gray('  Last Issue:'),
+          chalk.white(lastChange.diagnosis.issue)
+        );
+        console.log(
+          chalk.gray('  Success:'),
+          lastChange.recovery.success
+            ? chalk.green('✓ Yes')
+            : chalk.red('✗ No')
+        );
+      }
+    } catch {
+      console.log(chalk.white('\nRepair History:'));
+      console.log(chalk.gray('  No repairs recorded yet'));
+    }
+
+    console.log('');
+  } catch (error: any) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}

package/src/config/default.ts

@@ -0,0 +1,25 @@
+import { MonitorConfig, RecoveryConfig, AIClientConfig } from '@/types';
+
+export const defaultMonitorConfig: MonitorConfig = {
+  gatewayUrl: process.env.OPENCLAW_GATEWAY_URL || 'http://localhost:10002',
+  healthEndpoint: process.env.OPENCLAW_HEALTH_ENDPOINT || '/',
+  checkInterval: parseInt(process.env.HEALTH_CHECK_INTERVAL || '30000', 10),
+  timeout: parseInt(process.env.HEALTH_CHECK_TIMEOUT || '10000', 10),
+  maxRetries: parseInt(process.env.MAX_RETRY_ATTEMPTS || '3', 10),
+  failureThreshold: parseInt(process.env.FAILURE_THRESHOLD || '3', 10),
+};
+
+export const defaultRecoveryConfig: RecoveryConfig = {
+  useGitTracking: process.env.USE_GIT_TRACKING === 'true',
+  useGitHubCli: process.env.USE_GITHUB_CLI === 'true',
+  gitCommitPrefix: process.env.GIT_COMMIT_MESSAGE_PREFIX || '[AutoFix]',
+  backupBeforeChange: process.env.BACKUP_CONFIG_BEFORE_CHANGE !== 'false',
+  openclawConfigPath: process.env.OPENCLAW_CONFIG_PATH || '~/.openclaw',
+  maxRecoveryRetries: parseInt(process.env.MAX_RECOVERY_RETRIES || '3', 10),
+  recoveryCooldownMs: parseInt(process.env.RECOVERY_COOLDOWN_MS || '300000', 10), // 5 minutes
+};
+
+export const defaultAIConfig: AIClientConfig = {
+  provider: (process.env.AI_PROVIDER as AIClientConfig['provider']) || 'claude',
+  timeout: 300000, // 5 minutes for AI to complete the fix
+};

package/src/healthcheck/gateway-monitor.ts

@@ -0,0 +1,137 @@
+import cron from 'node-cron';
+import { HealthChecker } from './health-checker.js';
+import { AIOrchestrator } from '@/ai/ai-orchestrator.js';
+import { AutoFixer } from '@/recovery/auto-fixer.js';
+import logger from '@/utils/logger.js';
+import { MonitorConfig, AIClientConfig, RecoveryConfig } from '@/types';
+
+export class GatewayMonitor {
+  private healthChecker: HealthChecker;
+  private aiOrchestrator: AIOrchestrator;
+  private autoFixer: AutoFixer;
+  private cronJob: cron.ScheduledTask | null = null;
+  private isRecovering: boolean = false;
+  private consecutiveRecoveryFailures: number = 0;
+  private lastRecoveryEndTime: number = 0;
+  private maxRecoveryRetries: number;
+  private recoveryCooldownMs: number;
+
+  constructor(
+    monitorConfig: MonitorConfig,
+    aiConfig: AIClientConfig,
+    recoveryConfig: RecoveryConfig
+  ) {
+    this.healthChecker = new HealthChecker(monitorConfig);
+    this.aiOrchestrator = new AIOrchestrator(aiConfig, recoveryConfig);
+    this.autoFixer = new AutoFixer(recoveryConfig);
+    this.maxRecoveryRetries = recoveryConfig.maxRecoveryRetries;
+    this.recoveryCooldownMs = recoveryConfig.recoveryCooldownMs;
+  }
+
+  async start(): Promise<void> {
+    logger.info('Starting Gateway Monitor');
+
+    // Initialize AI orchestrator
+    await this.aiOrchestrator.initialize();
+
+    // Run initial health check
+    await this.performHealthCheck();
+
+    // Schedule periodic health checks
+    const intervalMs = this.healthChecker['config'].checkInterval;
+    const cronExpression = this.convertMsToCron(intervalMs);
+
+    this.cronJob = cron.schedule(cronExpression, async () => {
+      await this.performHealthCheck();
+    });
+
+    logger.info('Gateway Monitor started', { interval: intervalMs });
+  }
+
+  private async performHealthCheck(): Promise<void> {
+    if (this.isRecovering) {
+      logger.info('Recovery in progress, skipping health check');
+      return;
+    }
+
+    if (this.consecutiveRecoveryFailures >= this.maxRecoveryRetries) {
+      logger.warn('Max recovery retries reached, manual intervention required', {
+        consecutiveFailures: this.consecutiveRecoveryFailures,
+        maxRetries: this.maxRecoveryRetries,
+      });
+      return;
+    }
+
+    const cooldownRemaining = this.lastRecoveryEndTime + this.recoveryCooldownMs - Date.now();
+    if (cooldownRemaining > 0) {
+      logger.info('Recovery cooldown active, skipping health check', {
+        cooldownRemainingMs: cooldownRemaining,
+      });
+      return;
+    }
+
+    const result = await this.healthChecker.check();
+
+    if (!result.healthy && this.healthChecker.shouldTriggerRecovery()) {
+      logger.warn('Health check threshold exceeded, triggering recovery', {
+        consecutiveFailures: this.healthChecker.getConsecutiveFailures(),
+        recoveryAttempt: this.consecutiveRecoveryFailures + 1,
+        maxRetries: this.maxRecoveryRetries,
+      });
+      await this.triggerRecovery(result.error || 'Unknown error');
+    }
+  }
+
+  private async triggerRecovery(error: string): Promise<void> {
+    this.isRecovering = true;
+
+    try {
+      logger.info('Starting AI-powered recovery process', { error });
+
+      // AI directly diagnoses and fixes the problem
+      const diagnosis = await this.aiOrchestrator.diagnoseAndFix(error);
+      logger.info('AI diagnosis and fix completed', diagnosis);
+
+      // Record the fix (AI already applied it)
+      const recovery = await this.autoFixer.recordFix(diagnosis);
+      logger.info('Fix recorded', recovery);
+
+      if (recovery.success) {
+        this.healthChecker.reset();
+        this.consecutiveRecoveryFailures = 0;
+        logger.info('Recovery successful, resetting failure counter');
+      } else {
+        this.consecutiveRecoveryFailures++;
+        logger.error('Recovery verification failed', {
+          errors: recovery.errors,
+          consecutiveFailures: this.consecutiveRecoveryFailures,
+        });
+      }
+    } catch (error: any) {
+      this.consecutiveRecoveryFailures++;
+      logger.error('Recovery process failed', {
+        error: error.message,
+        consecutiveFailures: this.consecutiveRecoveryFailures,
+      });
+    } finally {
+      this.isRecovering = false;
+      this.lastRecoveryEndTime = Date.now();
+    }
+  }
+
+  private convertMsToCron(ms: number): string {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60) {
+      return `*/${seconds} * * * * *`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    return `*/${minutes} * * * *`;
+  }
+
+  stop(): void {
+    if (this.cronJob) {
+      this.cronJob.stop();
+      logger.info('Gateway Monitor stopped');
+    }
+  }
+}