process-watchdog 1.0.0

package/src/config.ts

@@ -0,0 +1,78 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { resolve, dirname, join } from 'path';
+import os from 'os';
+
+export interface WatchdogConfig {
+  port: number;
+  logLevel: string;
+  historyRetentionDays: number;
+  integrations: {
+    totalRecall: { enabled: boolean; url: string };
+    mah: { enabled: boolean; url: string };
+  };
+  plugins: Record<string, {
+    enabled: boolean;
+    interval: number;
+    autoFix: boolean;
+    thresholds: Record<string, number>;
+  }>;
+}
+
+type DeepPartial<T> = {
+  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function deepMerge<T extends Record<string, unknown>>(
+  target: T,
+  source: Record<string, unknown>,
+): T {
+  const result: Record<string, unknown> = { ...target };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = result[key];
+    if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+      result[key] = deepMerge(tgtVal, srcVal);
+    } else {
+      result[key] = srcVal;
+    }
+  }
+  return result as T;
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// src/config.ts lives in <project-root>/src/, so project root is one level up
+const PROJECT_ROOT = resolve(__dirname, '..');
+
+export async function loadConfig(
+  overrides?: DeepPartial<WatchdogConfig>,
+): Promise<WatchdogConfig> {
+  // 1. Read config/default.json from the project root
+  const defaultPath = join(PROJECT_ROOT, 'config', 'default.json');
+  const defaultRaw = await readFile(defaultPath, 'utf-8');
+  let config = JSON.parse(defaultRaw) as WatchdogConfig;
+
+  // 2. Read ~/.aidev/watchdog.json if it exists
+  const userConfigPath = join(os.homedir(), '.aidev', 'watchdog.json');
+  if (existsSync(userConfigPath)) {
+    const userRaw = await readFile(userConfigPath, 'utf-8');
+    const userConfig = JSON.parse(userRaw) as Record<string, unknown>;
+    config = deepMerge(config as unknown as Record<string, unknown>, userConfig) as unknown as WatchdogConfig;
+  }
+
+  // 3. Apply caller overrides
+  if (overrides) {
+    config = deepMerge(
+      config as unknown as Record<string, unknown>,
+      overrides as Record<string, unknown>,
+    ) as unknown as WatchdogConfig;
+  }
+
+  return config;
+}

package/src/index.ts

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { loadConfig } from './config.js';
+import { loadPlugins } from './plugins/plugin-loader.js';
+import { Scheduler } from './scheduler.js';
+import { HistoryStore } from './store/history.js';
+
+const program = new Command();
+
+program
+  .name('watchdog')
+  .description('AI Dev process watchdog — monitor and auto-fix system health')
+  .version('1.0.0');
+
+// ---------------------------------------------------------------------------
+// watchdog start
+// ---------------------------------------------------------------------------
+program
+  .command('start')
+  .description('Load config, start scheduler, and watch continuously')
+  .action(async () => {
+    const config = await loadConfig();
+    const plugins = loadPlugins(config);
+
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    const aidevDir = join(home, '.aidev');
+    mkdirSync(aidevDir, { recursive: true });
+    const dbPath = join(aidevDir, 'watchdog.db');
+
+    const store = new HistoryStore(dbPath);
+
+    const autoFix: Record<string, boolean> = {};
+    for (const [name, cfg] of Object.entries(config.plugins)) {
+      autoFix[name] = cfg.autoFix;
+    }
+
+    const scheduler = new Scheduler(plugins, { autoFix });
+    scheduler.start();
+
+    console.log(`[watchdog] Started with ${plugins.length} plugin(s). Press Ctrl+C to stop.`);
+
+    process.on('SIGINT', () => {
+      console.log('\n[watchdog] Stopping…');
+      scheduler.stop();
+      store.close();
+      process.exit(0);
+    });
+  });
+
+// ---------------------------------------------------------------------------
+// watchdog status
+// ---------------------------------------------------------------------------
+program
+  .command('status')
+  .description('Run check() on each plugin and print a summary line')
+  .action(async () => {
+    const config = await loadConfig();
+    const plugins = loadPlugins(config);
+
+    for (const plugin of plugins) {
+      try {
+        const result = await plugin.check();
+        const label =
+          result.status === 'healthy'
+            ? 'OK'
+            : result.status === 'warning'
+            ? 'WARN'
+            : 'CRIT';
+        console.log(`[${label}] ${plugin.name}: ${result.message}`);
+      } catch (err) {
+        console.error(`[ERR] ${plugin.name}: ${(err as Error).message}`);
+      }
+    }
+  });
+
+// ---------------------------------------------------------------------------
+// watchdog check [plugin]
+// ---------------------------------------------------------------------------
+program
+  .command('check [plugin]')
+  .description('Run check() for all or a specific plugin and print detailed metrics')
+  .action(async (pluginArg?: string) => {
+    const config = await loadConfig();
+    const plugins = loadPlugins(config);
+
+    const targets = pluginArg
+      ? plugins.filter((p) => p.name === pluginArg)
+      : plugins;
+
+    if (pluginArg && targets.length === 0) {
+      console.error(`No plugin found with name "${pluginArg}"`);
+      process.exit(1);
+    }
+
+    for (const plugin of targets) {
+      try {
+        const result = await plugin.check();
+        console.log(`\n--- ${plugin.name} ---`);
+        console.log(`Status : ${result.status}`);
+        console.log(`Message: ${result.message}`);
+        console.log('Metrics:');
+        for (const [key, value] of Object.entries(result.metrics)) {
+          console.log(`  ${key}: ${value}`);
+        }
+        if (result.suggestedActions.length > 0) {
+          console.log('Suggested actions:');
+          for (const action of result.suggestedActions) {
+            console.log(`  - ${action}`);
+          }
+        }
+      } catch (err) {
+        console.error(`[ERR] ${plugin.name}: ${(err as Error).message}`);
+      }
+    }
+  });
+
+// ---------------------------------------------------------------------------
+// watchdog fix [plugin]
+// ---------------------------------------------------------------------------
+program
+  .command('fix [plugin]')
+  .description('Run fix() for all or a specific plugin and print actions and resources freed')
+  .action(async (pluginArg?: string) => {
+    const config = await loadConfig();
+    const plugins = loadPlugins(config);
+
+    const targets = pluginArg
+      ? plugins.filter((p) => p.name === pluginArg)
+      : plugins;
+
+    if (pluginArg && targets.length === 0) {
+      console.error(`No plugin found with name "${pluginArg}"`);
+      process.exit(1);
+    }
+
+    for (const plugin of targets) {
+      try {
+        const result = await plugin.fix();
+        console.log(`\n--- ${plugin.name} ---`);
+        console.log(`Resources freed: ${result.resourcesFreed}`);
+        if (result.actionsKept.length > 0) {
+          console.log('Actions taken:');
+          for (const action of result.actionsKept) {
+            console.log(`  - ${action}`);
+          }
+        }
+        console.log('Before metrics:');
+        for (const [key, value] of Object.entries(result.beforeMetrics)) {
+          console.log(`  ${key}: ${value}`);
+        }
+        console.log('After metrics:');
+        for (const [key, value] of Object.entries(result.afterMetrics)) {
+          console.log(`  ${key}: ${value}`);
+        }
+      } catch (err) {
+        console.error(`[ERR] ${plugin.name}: ${(err as Error).message}`);
+      }
+    }
+  });
+
+// ---------------------------------------------------------------------------
+// watchdog api start
+// ---------------------------------------------------------------------------
+const apiCmd = program.command('api').description('API server commands');
+
+apiCmd
+  .command('start')
+  .description('Start the HTTP API server')
+  .action(async () => {
+    const config = await loadConfig();
+    const plugins = loadPlugins(config);
+
+    const home = process.env.HOME || process.env.USERPROFILE || '.';
+    const aidevDir = join(home, '.aidev');
+    mkdirSync(aidevDir, { recursive: true });
+    const dbPath = join(aidevDir, 'watchdog.db');
+
+    const store = new HistoryStore(dbPath);
+
+    // Dynamic import so that missing api/server.ts does not break the whole CLI at load time
+    const { startServer } = await import('./api/server.js');
+    startServer(store, plugins, config);
+
+    console.log(`[watchdog] API server started on port ${config.port}. Press Ctrl+C to stop.`);
+
+    process.on('SIGINT', () => {
+      console.log('\n[watchdog] Shutting down API server…');
+      store.close();
+      process.exit(0);
+    });
+  });
+
+// ---------------------------------------------------------------------------
+// watchdog install-service
+// ---------------------------------------------------------------------------
+program
+  .command('install-service')
+  .description('Install watchdog as a system service')
+  .action(async () => {
+    try {
+      const { installService } = await import('./installer/service.js');
+      await installService();
+    } catch (err) {
+      console.error('[watchdog] install-service failed:', (err as Error).message);
+      process.exit(1);
+    }
+  });
+
+// ---------------------------------------------------------------------------
+// watchdog uninstall-service
+// ---------------------------------------------------------------------------
+program
+  .command('uninstall-service')
+  .description('Uninstall the watchdog system service')
+  .action(async () => {
+    try {
+      const { uninstallService } = await import('./installer/service.js');
+      await uninstallService();
+    } catch (err) {
+      console.error('[watchdog] uninstall-service failed:', (err as Error).message);
+      process.exit(1);
+    }
+  });
+
+program.parseAsync(process.argv);

package/src/installer/service.ts

@@ -0,0 +1,50 @@
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
+export async function installService(): Promise<void> {
+  if (process.platform !== 'win32') {
+    console.error('Service installation currently supports Windows only.');
+    process.exit(1);
+  }
+
+  const { Service } = await import('node-windows');
+  const svc = new Service({
+    name: 'ProcessWatchdog',
+    description: 'Process Watchdog — PC health monitoring agent',
+    script: join(__dirname, '..', 'index.js'),
+    nodeOptions: [],
+    scriptOptions: 'start',
+  } as ConstructorParameters<typeof Service>[0]);
+
+  svc.on('install', () => {
+    svc.start();
+    console.log('[watchdog] Service installed and started');
+  });
+
+  svc.on('alreadyinstalled', () => {
+    console.log('[watchdog] Service already installed');
+  });
+
+  svc.install();
+}
+
+export async function uninstallService(): Promise<void> {
+  if (process.platform !== 'win32') {
+    console.error('Service uninstallation currently supports Windows only.');
+    process.exit(1);
+  }
+
+  const { Service } = await import('node-windows');
+  const svc = new Service({
+    name: 'ProcessWatchdog',
+    script: join(__dirname, '..', 'index.js'),
+  });
+
+  svc.on('uninstall', () => {
+    console.log('[watchdog] Service uninstalled');
+  });
+
+  svc.uninstall();
+}

package/src/integrations/mah.ts

@@ -0,0 +1,22 @@
+import { WatchdogConfig } from '../config.js';
+
+export async function registerProduct(config: WatchdogConfig): Promise<boolean> {
+  if (!config.integrations.mah.enabled) return false;
+
+  try {
+    const response = await fetch(`${config.integrations.mah.url}/api/v1/products`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        name: 'Process Watchdog',
+        runtime: 'mah-native',
+        description: 'Modular PC health agent with plugin architecture',
+        port: config.port,
+        healthEndpoint: `http://localhost:${config.port}/api/v1/health`,
+      }),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}

package/src/integrations/total-recall.ts

@@ -0,0 +1,27 @@
+import { WatchdogConfig } from '../config.js';
+
+export async function pushAlert(
+  config: WatchdogConfig,
+  plugin: string,
+  message: string,
+  severity: 'info' | 'warning' | 'critical',
+): Promise<boolean> {
+  if (!config.integrations.totalRecall.enabled) return false;
+
+  try {
+    const response = await fetch(`${config.integrations.totalRecall.url}/broadcast`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        source: 'process-watchdog',
+        plugin,
+        message,
+        severity,
+        timestamp: new Date().toISOString(),
+      }),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}

package/src/platform/index.ts

@@ -0,0 +1,13 @@
+import { PlatformAdapter } from './platform.interface.js';
+import { WindowsPlatform } from './windows.js';
+
+export function getPlatform(): PlatformAdapter {
+  switch (process.platform) {
+    case 'win32':
+      return new WindowsPlatform();
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}. Windows support only in v1.`);
+  }
+}
+
+export type { PlatformAdapter, ProcessInfo, MemoryInfo, DiskInfo, CpuSample, StartupItem } from './platform.interface.js';

package/src/platform/platform.interface.ts

@@ -0,0 +1,46 @@
+export interface ProcessInfo {
+  pid: number;
+  name: string;
+  memoryMB: number;
+  cpu: number;
+  responding: boolean;
+}
+
+export interface MemoryInfo {
+  totalMB: number;
+  freeMB: number;
+  usedPct: number;
+  pageFileUsageMB: number;
+}
+
+export interface DiskInfo {
+  drive: string;
+  totalGB: number;
+  freeGB: number;
+  usedPct: number;
+}
+
+export interface CpuSample {
+  usedPct: number;
+  timestamp: Date;
+}
+
+export interface StartupItem {
+  name: string;
+  command: string;
+  location: string;
+  enabled: boolean;
+}
+
+export interface PlatformAdapter {
+  getProcesses(): Promise<ProcessInfo[]>;
+  getProcessesByName(name: string): Promise<ProcessInfo[]>;
+  getListeningPids(): Promise<number[]>;
+  killProcess(pid: number): Promise<boolean>;
+  getMemoryInfo(): Promise<MemoryInfo>;
+  getDiskInfo(): Promise<DiskInfo[]>;
+  getCpuUsage(samples: number, intervalMs: number): Promise<CpuSample[]>;
+  getStartupItems(): Promise<StartupItem[]>;
+  disableStartupItem(name: string): Promise<boolean>;
+  getTempDirs(): string[];
+}