process-watchdog 1.0.0

package/tests/plugins/disk-health.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { DiskHealthPlugin } from '../../src/plugins/disk-health.js';
+
+const describeWindows = process.platform === 'win32' ? describe : describe.skip;
+
+describeWindows('DiskHealthPlugin', () => {
+  let plugin: DiskHealthPlugin;
+
+  beforeAll(() => {
+    plugin = new DiskHealthPlugin();
+    plugin.configure({
+      enabled: true,
+      interval: 1800000,
+      autoFix: true,
+      thresholds: { warningPct: 80, criticalPct: 90, tempFileAgeDays: 7 },
+    });
+  });
+
+  it('check() returns diskUsedPct between 0 and 100', async () => {
+    const result = await plugin.check();
+    expect(['healthy', 'warning', 'critical']).toContain(result.status);
+    expect(result.metrics).toHaveProperty('diskUsedPct');
+    expect(result.metrics.diskUsedPct).toBeGreaterThanOrEqual(0);
+    expect(result.metrics.diskUsedPct).toBeLessThanOrEqual(100);
+  });
+
+  it('check() returns diskFreeGB and diskTotalGB as positive numbers', async () => {
+    const result = await plugin.check();
+    expect(result.metrics).toHaveProperty('diskFreeGB');
+    expect(result.metrics).toHaveProperty('diskTotalGB');
+    expect(result.metrics.diskFreeGB).toBeGreaterThanOrEqual(0);
+    expect(result.metrics.diskTotalGB).toBeGreaterThan(0);
+  });
+
+  it('check() returns a non-empty message', async () => {
+    const result = await plugin.check();
+    expect(typeof result.message).toBe('string');
+    expect(result.message.length).toBeGreaterThan(0);
+  });
+
+  it('check() returns warning/critical when warningPct threshold is very low', async () => {
+    plugin.configure({
+      enabled: true,
+      interval: 1800000,
+      autoFix: true,
+      thresholds: { warningPct: 1, criticalPct: 2, tempFileAgeDays: 7 },
+    });
+    const result = await plugin.check();
+    expect(['warning', 'critical']).toContain(result.status);
+    // Reset
+    plugin.configure({
+      enabled: true,
+      interval: 1800000,
+      autoFix: true,
+      thresholds: { warningPct: 80, criticalPct: 90, tempFileAgeDays: 7 },
+    });
+  });
+
+  it('fix() returns valid FixResult', async () => {
+    const result = await plugin.fix();
+    expect(result).toHaveProperty('actionsKept');
+    expect(result).toHaveProperty('resourcesFreed');
+    expect(result).toHaveProperty('beforeMetrics');
+    expect(result).toHaveProperty('afterMetrics');
+    expect(Array.isArray(result.actionsKept)).toBe(true);
+    expect(result.beforeMetrics).toHaveProperty('diskFreeGB');
+    expect(result.afterMetrics).toHaveProperty('diskFreeGB');
+  }, 30000);
+});

package/tests/plugins/memory-monitor.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { MemoryMonitorPlugin } from '../../src/plugins/memory-monitor.js';
+
+const describeWindows = process.platform === 'win32' ? describe : describe.skip;
+
+describeWindows('MemoryMonitorPlugin', () => {
+  let plugin: MemoryMonitorPlugin;
+
+  beforeAll(() => {
+    plugin = new MemoryMonitorPlugin();
+    plugin.configure({ enabled: true, interval: 120000, autoFix: false, thresholds: { warningPct: 85, criticalPct: 95 } });
+  });
+
+  it('check() returns metrics with ramUsedPct, ramFreeMB, ramTotalMB, pageFileMB — all valid numbers', async () => {
+    const result = await plugin.check();
+    expect(typeof result.metrics.ramUsedPct).toBe('number');
+    expect(typeof result.metrics.ramFreeMB).toBe('number');
+    expect(typeof result.metrics.ramTotalMB).toBe('number');
+    expect(typeof result.metrics.pageFileMB).toBe('number');
+    expect(isFinite(result.metrics.ramUsedPct)).toBe(true);
+    expect(isFinite(result.metrics.ramFreeMB)).toBe(true);
+    expect(isFinite(result.metrics.ramTotalMB)).toBe(true);
+    expect(isFinite(result.metrics.pageFileMB)).toBe(true);
+  });
+
+  it('ramUsedPct is between 0 and 100', async () => {
+    const result = await plugin.check();
+    expect(result.metrics.ramUsedPct).toBeGreaterThanOrEqual(0);
+    expect(result.metrics.ramUsedPct).toBeLessThanOrEqual(100);
+  });
+
+  it('status is one of healthy/warning/critical', async () => {
+    const result = await plugin.check();
+    expect(['healthy', 'warning', 'critical']).toContain(result.status);
+  });
+
+  it('check() returns critical status when criticalPct threshold is very low', async () => {
+    plugin.configure({ enabled: true, interval: 120000, autoFix: false, thresholds: { warningPct: 1, criticalPct: 2 } });
+    const result = await plugin.check();
+    expect(result.status).toBe('critical');
+    // Reset
+    plugin.configure({ enabled: true, interval: 120000, autoFix: false, thresholds: { warningPct: 85, criticalPct: 95 } });
+  });
+
+  it('fix() returns alert-only FixResult with correct shape', async () => {
+    const result = await plugin.fix();
+    expect(result).toHaveProperty('actionsKept');
+    expect(result).toHaveProperty('resourcesFreed');
+    expect(result).toHaveProperty('beforeMetrics');
+    expect(result).toHaveProperty('afterMetrics');
+    expect(Array.isArray(result.actionsKept)).toBe(true);
+    expect(result.actionsKept).toContain('Alert pushed (no auto-fix for memory)');
+    expect(result.resourcesFreed).toBe('0 MB (alert only)');
+    // before and after metrics should be the same (alert only, no fix)
+    expect(result.beforeMetrics).toEqual(result.afterMetrics);
+  });
+});

package/tests/plugins/plugin-loader.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import { loadPlugins } from '../../src/plugins/plugin-loader.js';
+import { loadConfig } from '../../src/config.js';
+
+describe('loadPlugins', () => {
+  it('loads all enabled plugins from config', async () => {
+    const config = await loadConfig();
+    const plugins = loadPlugins(config);
+    const names = plugins.map(p => p.name);
+    expect(names).toContain('process-guard');
+    expect(names).toContain('memory-monitor');
+    expect(names).toContain('disk-health');
+    expect(names).toContain('startup-optimizer');
+    expect(names).toContain('cpu-monitor');
+  });
+
+  it('skips disabled plugins', async () => {
+    const config = await loadConfig({
+      plugins: { 'process-guard': { enabled: false, interval: 0, autoFix: false, thresholds: {} } },
+    });
+    const plugins = loadPlugins(config);
+    const names = plugins.map(p => p.name);
+    expect(names).not.toContain('process-guard');
+  });
+
+  it('configures plugins with config thresholds', async () => {
+    const config = await loadConfig();
+    const plugins = loadPlugins(config);
+    for (const plugin of plugins) {
+      expect(plugin.name).toBeTruthy();
+      expect(plugin.description).toBeTruthy();
+      expect(plugin.defaultInterval).toBeGreaterThanOrEqual(0);
+    }
+  });
+});

package/tests/plugins/process-guard.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { ProcessGuardPlugin } from '../../src/plugins/process-guard.js';
+
+const describeWindows = process.platform === 'win32' ? describe : describe.skip;
+
+describeWindows('ProcessGuardPlugin', () => {
+  let plugin: ProcessGuardPlugin;
+
+  beforeAll(() => {
+    plugin = new ProcessGuardPlugin();
+    plugin.configure({ enabled: true, interval: 300000, autoFix: true, thresholds: { node: 50, cmd: 20, bash: 10 } });
+  });
+
+  it('check() returns valid HealthCheck with process counts', async () => {
+    const result = await plugin.check();
+    expect(['healthy', 'warning', 'critical']).toContain(result.status);
+    expect(result.metrics).toHaveProperty('nodeCount');
+    expect(result.metrics).toHaveProperty('cmdCount');
+    expect(result.metrics).toHaveProperty('bashCount');
+    expect(result.metrics).toHaveProperty('totalOrphans');
+    expect(typeof result.message).toBe('string');
+  });
+
+  it('check() returns warning/critical when thresholds are very low', async () => {
+    plugin.configure({ enabled: true, interval: 300000, autoFix: true, thresholds: { node: 1, cmd: 1, bash: 1 } });
+    const result = await plugin.check();
+    expect(['warning', 'critical']).toContain(result.status);
+    // Reset
+    plugin.configure({ enabled: true, interval: 300000, autoFix: true, thresholds: { node: 50, cmd: 20, bash: 10 } });
+  });
+
+  it('fix() returns valid FixResult', async () => {
+    const result = await plugin.fix();
+    expect(result).toHaveProperty('actionsKept');
+    expect(result).toHaveProperty('resourcesFreed');
+    expect(result).toHaveProperty('beforeMetrics');
+    expect(result).toHaveProperty('afterMetrics');
+    expect(Array.isArray(result.actionsKept)).toBe(true);
+  }, 30000);
+});

package/tests/plugins/startup-optimizer.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { StartupOptimizerPlugin } from '../../src/plugins/startup-optimizer.js';
+
+const describeWindows = process.platform === 'win32' ? describe : describe.skip;
+
+describeWindows('StartupOptimizerPlugin', () => {
+  let plugin: StartupOptimizerPlugin;
+
+  beforeAll(() => {
+    plugin = new StartupOptimizerPlugin();
+    plugin.configure({ enabled: true, interval: 0, autoFix: false, thresholds: {} });
+  });
+
+  it('check() returns startupItemCount as a number', async () => {
+    const result = await plugin.check();
+    expect(['healthy', 'warning', 'critical']).toContain(result.status);
+    expect(result.metrics).toHaveProperty('startupItemCount');
+    expect(typeof result.metrics.startupItemCount).toBe('number');
+    expect(result.metrics.startupItemCount).toBeGreaterThanOrEqual(0);
+  });
+
+  it('check() returns bloatItemCount as a non-negative number', async () => {
+    const result = await plugin.check();
+    expect(result.metrics).toHaveProperty('bloatItemCount');
+    expect(typeof result.metrics.bloatItemCount).toBe('number');
+    expect(result.metrics.bloatItemCount).toBeGreaterThanOrEqual(0);
+  });
+
+  it('check() bloatItemCount does not exceed startupItemCount', async () => {
+    const result = await plugin.check();
+    expect(result.metrics.bloatItemCount).toBeLessThanOrEqual(result.metrics.startupItemCount);
+  });
+
+  it('check() returns a non-empty message', async () => {
+    const result = await plugin.check();
+    expect(typeof result.message).toBe('string');
+    expect(result.message.length).toBeGreaterThan(0);
+  });
+
+  it('fix() returns valid FixResult with before/after metrics', async () => {
+    const result = await plugin.fix();
+    expect(result).toHaveProperty('actionsKept');
+    expect(result).toHaveProperty('resourcesFreed');
+    expect(result).toHaveProperty('beforeMetrics');
+    expect(result).toHaveProperty('afterMetrics');
+    expect(Array.isArray(result.actionsKept)).toBe(true);
+    expect(result.beforeMetrics).toHaveProperty('startupItemCount');
+    expect(result.afterMetrics).toHaveProperty('startupItemCount');
+  });
+});

package/tests/scheduler.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Scheduler } from '../src/scheduler.js';
+import { WatchdogPlugin, HealthCheck, FixResult, PluginConfig } from '../src/plugins/plugin.interface.js';
+
+class MockPlugin implements WatchdogPlugin {
+  name = 'mock-plugin';
+  description = 'Test plugin';
+  defaultInterval = 1000;
+  checkCount = 0;
+  fixCount = 0;
+  private status: 'healthy' | 'critical' = 'healthy';
+
+  configure(_opts: PluginConfig): void {}
+  setStatus(s: 'healthy' | 'critical') { this.status = s; }
+
+  async check(): Promise<HealthCheck> {
+    this.checkCount++;
+    return { status: this.status, metrics: { count: this.checkCount }, message: 'mock', suggestedActions: [] };
+  }
+
+  async fix(): Promise<FixResult> {
+    this.fixCount++;
+    return { actionsKept: ['mock fix'], resourcesFreed: '0', beforeMetrics: {}, afterMetrics: {} };
+  }
+}
+
+describe('Scheduler', () => {
+  let plugin: MockPlugin;
+  let scheduler: Scheduler;
+
+  beforeEach(() => {
+    plugin = new MockPlugin();
+  });
+
+  afterEach(() => {
+    scheduler?.stop();
+  });
+
+  it('runs check() on the given interval', async () => {
+    scheduler = new Scheduler([plugin], { autoFix: {} });
+    scheduler.start(100);
+
+    await new Promise(resolve => setTimeout(resolve, 350));
+
+    expect(plugin.checkCount).toBeGreaterThanOrEqual(2);
+  });
+
+  it('calls fix() when check returns critical and autoFix is true', async () => {
+    plugin.setStatus('critical');
+    scheduler = new Scheduler([plugin], { autoFix: { 'mock-plugin': true } });
+    scheduler.start(100);
+
+    await new Promise(resolve => setTimeout(resolve, 250));
+    scheduler.stop();
+
+    expect(plugin.fixCount).toBeGreaterThanOrEqual(1);
+  });
+
+  it('does NOT call fix() when check returns healthy', async () => {
+    plugin.setStatus('healthy');
+    scheduler = new Scheduler([plugin], { autoFix: { 'mock-plugin': true } });
+    scheduler.start(100);
+
+    await new Promise(resolve => setTimeout(resolve, 250));
+    scheduler.stop();
+
+    expect(plugin.fixCount).toBe(0);
+  });
+});

package/tests/store/history.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { HistoryStore } from '../../src/store/history.js';
+import { existsSync, unlinkSync } from 'fs';
+
+const TEST_DB = './test-history.db';
+
+afterEach(() => {
+  if (existsSync(TEST_DB)) {
+    unlinkSync(TEST_DB);
+  }
+});
+
+describe('HistoryStore', () => {
+  it('recordCheck() then getHistory() returns the recorded check', async () => {
+    const store = new HistoryStore(TEST_DB);
+    const metrics = { cpu: 45.2, memory: 1024 };
+
+    store.recordCheck('process-guard', 'ok', metrics, 'All good');
+
+    const history = store.getHistory(null, 10);
+    expect(history).toHaveLength(1);
+
+    const row = history[0];
+    expect(row.plugin).toBe('process-guard');
+    expect(row.type).toBe('check');
+    expect(row.status).toBe('ok');
+    expect(row.metrics).toBe(JSON.stringify(metrics));
+    expect(row.message).toBe('All good');
+    expect(row.timestamp).toBeDefined();
+
+    store.close();
+  });
+
+  it('recordFix() then getHistory() returns the recorded fix with type="fix" and actions array', async () => {
+    const store = new HistoryStore(TEST_DB);
+    const actions = ['killed process node (pid 1234)', 'freed 512MB'];
+
+    store.recordFix('process-guard', actions, '512MB');
+
+    const history = store.getHistory(null, 10);
+    expect(history).toHaveLength(1);
+
+    const row = history[0];
+    expect(row.plugin).toBe('process-guard');
+    expect(row.type).toBe('fix');
+    expect(row.status).toBe('fixed');
+    expect(row.actions).toBe(JSON.stringify(actions));
+    expect(row.message).toBe('512MB');
+
+    store.close();
+  });
+
+  it('getLastChecks() returns one entry per plugin (the latest check for each)', async () => {
+    const store = new HistoryStore(TEST_DB);
+
+    store.recordCheck('process-guard', 'ok', { cpu: 10 }, 'first');
+    store.recordCheck('process-guard', 'warning', { cpu: 80 }, 'second');
+    store.recordCheck('disk-guard', 'ok', { disk: 50 }, 'disk check');
+
+    const lastChecks = store.getLastChecks();
+
+    expect(Object.keys(lastChecks)).toHaveLength(2);
+    expect(lastChecks['process-guard']).toBeDefined();
+    expect(lastChecks['disk-guard']).toBeDefined();
+
+    // Should be the latest check for process-guard
+    expect(lastChecks['process-guard'].status).toBe('warning');
+    expect(lastChecks['process-guard'].message).toBe('second');
+
+    // Should be the only check for disk-guard
+    expect(lastChecks['disk-guard'].status).toBe('ok');
+    expect(lastChecks['disk-guard'].message).toBe('disk check');
+
+    store.close();
+  });
+
+  it('getHistory() filters by plugin when plugin is specified', async () => {
+    const store = new HistoryStore(TEST_DB);
+
+    store.recordCheck('process-guard', 'ok', {}, 'pg check');
+    store.recordCheck('disk-guard', 'ok', {}, 'dg check');
+
+    const history = store.getHistory('process-guard', 10);
+    expect(history).toHaveLength(1);
+    expect(history[0].plugin).toBe('process-guard');
+
+    store.close();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ['tests/**/*.test.ts'],
+    testTimeout: 60000,
+    fileParallelism: false,
+  },
+});