openclaw-watcher 0.0.1

package/src/setup/safe-config-generator.ts

@@ -0,0 +1,100 @@
+import fs from 'fs/promises';
+import path from 'path';
+import logger from '@/utils/logger.js';
+
+export class SafeConfigGenerator {
+  private configPath: string;
+
+  constructor(configPath: string) {
+    this.configPath = configPath;
+  }
+
+  async generate(): Promise<void> {
+    const openclawJsonPath = path.join(this.configPath, 'openclaw.json');
+    const safeJsonPath = path.join(this.configPath, 'openclaw.safe.json');
+
+    try {
+      // Read original config
+      const content = await fs.readFile(openclawJsonPath, 'utf-8');
+      const config = JSON.parse(content);
+
+      // Redact sensitive data
+      const safeConfig = this.redactSensitiveData(config);
+
+      // Write safe config
+      await fs.writeFile(safeJsonPath, JSON.stringify(safeConfig, null, 2), 'utf-8');
+
+      logger.info('Safe configuration generated', { path: safeJsonPath });
+    } catch (error: any) {
+      logger.error('Failed to generate safe configuration', { error: error.message });
+      throw error;
+    }
+  }
+
+  async update(): Promise<void> {
+    // Same as generate - always regenerate from openclaw.json
+    await this.generate();
+  }
+
+  private redactSensitiveData(obj: any): any {
+    if (typeof obj !== 'object' || obj === null) {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.redactSensitiveData(item));
+    }
+
+    const result: any = {};
+
+    for (const [key, value] of Object.entries(obj)) {
+      const lowerKey = key.toLowerCase();
+
+      // Check if key indicates sensitive data
+      if (
+        lowerKey.includes('key') ||
+        lowerKey.includes('token') ||
+        lowerKey.includes('secret') ||
+        lowerKey.includes('password') ||
+        lowerKey.includes('apikey') ||
+        lowerKey.includes('api_key') ||
+        lowerKey === 'bearer'
+      ) {
+        // Replace with placeholder
+        result[key] = this.getPlaceholder(lowerKey, value);
+      } else if (typeof value === 'object' && value !== null) {
+        // Recursively process nested objects
+        result[key] = this.redactSensitiveData(value);
+      } else {
+        // Keep non-sensitive values
+        result[key] = value;
+      }
+    }
+
+    return result;
+  }
+
+  private getPlaceholder(key: string, value: any): string {
+    if (typeof value !== 'string') {
+      return '<REDACTED>';
+    }
+
+    if (key.includes('apikey') || key.includes('api_key')) {
+      return '<YOUR_API_KEY_HERE>';
+    }
+    if (key.includes('token')) {
+      return '<YOUR_TOKEN_HERE>';
+    }
+    if (key.includes('secret')) {
+      return '<YOUR_SECRET_HERE>';
+    }
+    if (key.includes('password')) {
+      return '<YOUR_PASSWORD_HERE>';
+    }
+    if (key.includes('key')) {
+      return '<YOUR_KEY_HERE>';
+    }
+
+    return '<REDACTED>';
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,67 @@
+export interface HealthCheckResult {
+  healthy: boolean;
+  timestamp: Date;
+  endpoint: string;
+  responseTime?: number;
+  error?: string;
+  statusCode?: number;
+}
+
+export interface DiagnosisResult {
+  issue: string;
+  rootCause: string;
+  suggestedFix: string;
+  commands: string[];
+  configChanges?: ConfigChange[];
+  confidence: number;
+}
+
+export interface ConfigChange {
+  file: string;
+  path: string;
+  oldValue: unknown;
+  newValue: unknown;
+  reason: string;
+}
+
+export interface RecoveryResult {
+  success: boolean;
+  actions: string[];
+  errors?: string[];
+  configChanges?: ConfigChange[];
+  restartRequired: boolean;
+}
+
+export interface ChangeRecord {
+  timestamp: Date;
+  trigger: string;
+  diagnosis: DiagnosisResult;
+  recovery: RecoveryResult;
+  gitCommit?: string;
+}
+
+export type AIProvider = 'claude' | 'kimi';
+
+export interface AIClientConfig {
+  provider: AIProvider;
+  timeout?: number;
+}
+
+export interface MonitorConfig {
+  gatewayUrl: string;
+  healthEndpoint: string;
+  checkInterval: number;
+  timeout: number;
+  maxRetries: number;
+  failureThreshold: number;
+}
+
+export interface RecoveryConfig {
+  useGitTracking: boolean;
+  useGitHubCli: boolean;
+  gitCommitPrefix: string;
+  backupBeforeChange: boolean;
+  openclawConfigPath: string;
+  maxRecoveryRetries: number;
+  recoveryCooldownMs: number;
+}

package/src/utils/executor.ts

@@ -0,0 +1,75 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import logger from './logger.js';
+
+const execAsync = promisify(exec);
+
+export interface CommandResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  success: boolean;
+}
+
+export class CommandExecutor {
+  private timeout: number;
+
+  constructor(timeout: number = 30000) {
+    this.timeout = timeout;
+  }
+
+  async execute(command: string, cwd?: string): Promise<CommandResult> {
+    logger.info('Executing command', { command, cwd });
+
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        timeout: this.timeout,
+        cwd,
+        shell: '/bin/bash',
+      });
+
+      logger.info('Command executed successfully', { command, stdout, stderr });
+
+      return {
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: 0,
+        success: true,
+      };
+    } catch (error: any) {
+      logger.error('Command execution failed', {
+        command,
+        error: error.message,
+        stdout: error.stdout,
+        stderr: error.stderr,
+      });
+
+      return {
+        stdout: error.stdout?.trim() || '',
+        stderr: error.stderr?.trim() || error.message,
+        exitCode: error.code || 1,
+        success: false,
+      };
+    }
+  }
+
+  async executeOpenClawCommand(subcommand: string): Promise<CommandResult> {
+    const command = `openclaw ${subcommand}`;
+    return this.execute(command);
+  }
+
+  async restartGateway(): Promise<CommandResult> {
+    logger.info('Attempting to restart OpenClaw gateway');
+    return this.executeOpenClawCommand('gateway restart');
+  }
+
+  async getGatewayStatus(): Promise<CommandResult> {
+    return this.executeOpenClawCommand('gateway status');
+  }
+
+  async getGatewayLogs(lines: number = 100): Promise<CommandResult> {
+    return this.executeOpenClawCommand(`gateway logs --lines ${lines}`);
+  }
+}
+
+export const executor = new CommandExecutor();

package/src/utils/git-manager.ts

@@ -0,0 +1,121 @@
+import simpleGit, { SimpleGit } from 'simple-git';
+import logger from './logger.js';
+import path from 'path';
+import fs from 'fs/promises';
+
+export class GitManager {
+  private git: SimpleGit;
+  private repoPath: string;
+
+  constructor(repoPath: string) {
+    this.repoPath = repoPath;
+    this.git = simpleGit(repoPath);
+  }
+
+  async init(): Promise<void> {
+    try {
+      const isRepo = await this.git.checkIsRepo();
+      if (!isRepo) {
+        logger.info('Initializing git repository', { path: this.repoPath });
+        await this.git.init();
+        await this.createGitignore();
+        await this.git.add('.gitignore');
+        await this.git.commit('Initial commit: Setup config tracking');
+      }
+    } catch (error: any) {
+      logger.error('Failed to initialize git repository', { error: error.message });
+      throw error;
+    }
+  }
+
+  private async createGitignore(): Promise<void> {
+    const gitignorePath = path.join(this.repoPath, '.gitignore');
+    const content = `# Ignore sensitive files
+*.key
+*.pem
+*.secret
+secrets/
+*.env
+`;
+    await fs.writeFile(gitignorePath, content, 'utf-8');
+  }
+
+  async commit(message: string, files?: string[]): Promise<string> {
+    try {
+      if (files && files.length > 0) {
+        await this.git.add(files);
+      } else {
+        await this.git.add('.');
+      }
+
+      const status = await this.git.status();
+      if (status.files.length === 0) {
+        logger.info('No changes to commit');
+        return '';
+      }
+
+      const result = await this.git.commit(message);
+      logger.info('Changes committed', { message, hash: result.commit });
+      return result.commit;
+    } catch (error: any) {
+      logger.error('Failed to commit changes', { error: error.message });
+      throw error;
+    }
+  }
+
+  async createBackup(files: string[]): Promise<void> {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupBranch = `backup-${timestamp}`;
+
+      const currentBranch = await this.git.revparse(['--abbrev-ref', 'HEAD']);
+      await this.git.checkoutBranch(backupBranch, currentBranch.trim());
+      await this.git.checkout(currentBranch.trim());
+
+      logger.info('Backup created', { branch: backupBranch, files });
+    } catch (error: any) {
+      logger.error('Failed to create backup', { error: error.message });
+      throw error;
+    }
+  }
+
+  async getDiff(file?: string): Promise<string> {
+    try {
+      const diff = file ? await this.git.diff([file]) : await this.git.diff();
+      return diff;
+    } catch (error: any) {
+      logger.error('Failed to get diff', { error: error.message });
+      return '';
+    }
+  }
+
+  async hasRemote(): Promise<boolean> {
+    try {
+      const remotes = await this.git.getRemotes();
+      return remotes.some((r) => r.name === 'origin');
+    } catch {
+      return false;
+    }
+  }
+
+  async push(): Promise<boolean> {
+    try {
+      await this.git.push('origin', 'HEAD');
+      logger.info('Pushed to remote');
+      return true;
+    } catch (error: any) {
+      logger.warn('Failed to push to remote', { error: error.message });
+      return false;
+    }
+  }
+
+  async getLog(maxCount: number = 10): Promise<string> {
+    try {
+      const log = await this.git.log({ maxCount });
+      return log.all.map((commit) => `${commit.hash.substring(0, 7)} - ${commit.message}`).join('\n');
+    } catch (error: any) {
+      logger.error('Failed to get log', { error: error.message });
+      return '';
+    }
+  }
+}

package/src/utils/github-cli.ts

@@ -0,0 +1,37 @@
+import { CommandExecutor, CommandResult } from './executor.js';
+import logger from './logger.js';
+
+export class GitHubCli {
+  private executor: CommandExecutor;
+
+  constructor() {
+    this.executor = new CommandExecutor(60000);
+  }
+
+  async isInstalled(): Promise<boolean> {
+    const result = await this.executor.execute('gh --version');
+    return result.success;
+  }
+
+  async isAuthenticated(): Promise<boolean> {
+    const result = await this.executor.execute('gh auth status');
+    return result.success;
+  }
+
+  async createRepoAndPush(
+    repoName: string,
+    localPath: string
+  ): Promise<CommandResult> {
+    const command = `gh repo create ${repoName} --private --source="${localPath}" --remote=origin --push`;
+    const result = await this.executor.execute(command, localPath);
+    if (result.success) {
+      logger.info('GitHub repository created and pushed', { repoName });
+    } else {
+      logger.error('Failed to create GitHub repository', {
+        repoName,
+        stderr: result.stderr,
+      });
+    }
+    return result;
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,39 @@
+import winston from 'winston';
+import { getLogFilePath } from '@/utils/paths.js';
+
+const logLevel = process.env.LOG_LEVEL || 'info';
+const logFilePath = process.env.LOG_FILE_PATH || getLogFilePath();
+
+const logger = winston.createLogger({
+  level: logLevel,
+  format: winston.format.combine(
+    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+    winston.format.errors({ stack: true }),
+    winston.format.splat(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'openclaw-healthcheck' },
+  transports: [
+    new winston.transports.File({
+      filename: logFilePath.replace('.log', '-error.log'),
+      level: 'error',
+    }),
+    new winston.transports.File({ filename: logFilePath }),
+  ],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.printf(({ level, message, timestamp, ...meta }) => {
+          const metaStr = Object.keys(meta).length ? JSON.stringify(meta, null, 2) : '';
+          return `${timestamp} [${level}]: ${message} ${metaStr}`;
+        })
+      ),
+    })
+  );
+}
+
+export default logger;

package/src/utils/paths.ts

@@ -0,0 +1,25 @@
+import path from 'path';
+import os from 'os';
+
+const WATCHER_HOME =
+  process.env.WATCHER_HOME || path.join(os.homedir(), '.openclaw-watcher');
+
+export function getWatcherHome(): string {
+  return WATCHER_HOME;
+}
+
+export function getConfigPath(): string {
+  return path.join(WATCHER_HOME, 'config.json');
+}
+
+export function getLogsDir(): string {
+  return path.join(WATCHER_HOME, 'logs');
+}
+
+export function getLogFilePath(): string {
+  return path.join(WATCHER_HOME, 'logs', 'healthcheck.log');
+}
+
+export function getChangesFilePath(): string {
+  return path.join(WATCHER_HOME, 'logs', 'changes.json');
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}