opc-agent 4.1.0 → 4.1.2

package/tests/cron-engine.test.ts

@@ -1,101 +1,101 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { CronEngine, frequencyToCron } from '../src/scheduler/cron-engine';
-import type { ScheduleTask } from '../src/scheduler/cron-engine';
-import { existsSync, unlinkSync } from 'fs';
-import { join } from 'path';
-import * as os from 'os';
-
-describe('CronEngine', () => {
-  let engine: CronEngine;
-  const schedulesPath = join(os.homedir(), '.opc', 'schedules.json');
-
-  beforeEach(() => {
-    engine = new CronEngine(async () => {});
-  });
-
-  afterEach(() => {
-    engine.stop();
-  });
-
-  describe('frequencyToCron', () => {
-    it('converts daily + time to cron', () => {
-      expect(frequencyToCron('daily', '08:30')).toBe('30 8 * * *');
-    });
-
-    it('converts weekly to Monday cron', () => {
-      expect(frequencyToCron('weekly', '09:00')).toBe('0 9 * * 1');
-    });
-
-    it('converts monthly to 1st of month', () => {
-      expect(frequencyToCron('monthly', '10:15')).toBe('15 10 1 * *');
-    });
-
-    it('defaults to 9:00 when no time given', () => {
-      expect(frequencyToCron('daily')).toBe('0 9 * * *');
-    });
-  });
-
-  describe('CRUD operations', () => {
-    it('creates a task', () => {
-      const task = engine.createTask({
-        name: 'Test Task',
-        schedule: '0 9 * * *',
-        description: 'Test description',
-        frequency: 'daily',
-        time: '09:00',
-        outputChannel: 'web',
-        enabled: true,
-      });
-      expect(task.id).toBeTruthy();
-      expect(task.name).toBe('Test Task');
-      expect(task.createdAt).toBeTruthy();
-    });
-
-    it('lists tasks', () => {
-      engine.createTask({ name: 'A', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
-      engine.createTask({ name: 'B', schedule: '0 10 * * *', description: '', frequency: 'daily', outputChannel: 'telegram', enabled: false });
-      const tasks = engine.listTasks();
-      expect(tasks.length).toBeGreaterThanOrEqual(2);
-    });
-
-    it('updates a task', () => {
-      const task = engine.createTask({ name: 'Original', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
-      const updated = engine.updateTask(task.id, { name: 'Updated', enabled: false });
-      expect(updated).not.toBeNull();
-      expect(updated!.name).toBe('Updated');
-      expect(updated!.enabled).toBe(false);
-    });
-
-    it('deletes a task', () => {
-      const task = engine.createTask({ name: 'ToDelete', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
-      expect(engine.deleteTask(task.id)).toBe(true);
-      expect(engine.getTask(task.id)).toBeUndefined();
-    });
-
-    it('returns false for deleting non-existent task', () => {
-      expect(engine.deleteTask('nonexistent')).toBe(false);
-    });
-
-    it('returns null for updating non-existent task', () => {
-      expect(engine.updateTask('nonexistent', { name: 'x' })).toBeNull();
-    });
-  });
-
-  describe('run task', () => {
-    it('runs a task immediately', async () => {
-      const handler = vi.fn();
-      const eng = new CronEngine(handler);
-      const task = eng.createTask({ name: 'RunMe', schedule: '0 9 * * *', description: 'test', frequency: 'daily', outputChannel: 'web', enabled: true });
-      eng.start();
-      const result = await eng.runTask(task.id);
-      expect(result).toBe(true);
-      expect(handler).toHaveBeenCalled();
-      eng.stop();
-    });
-
-    it('returns false for running non-existent task', async () => {
-      const result = await engine.runTask('nonexistent');
-      expect(result).toBe(false);
-    });
-  });
-});
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CronEngine, frequencyToCron } from '../src/scheduler/cron-engine';
+import type { ScheduleTask } from '../src/scheduler/cron-engine';
+import { existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import * as os from 'os';
+
+describe('CronEngine', () => {
+  let engine: CronEngine;
+  const schedulesPath = join(os.homedir(), '.opc', 'schedules.json');
+
+  beforeEach(() => {
+    engine = new CronEngine(async () => {});
+  });
+
+  afterEach(() => {
+    engine.stop();
+  });
+
+  describe('frequencyToCron', () => {
+    it('converts daily + time to cron', () => {
+      expect(frequencyToCron('daily', '08:30')).toBe('30 8 * * *');
+    });
+
+    it('converts weekly to Monday cron', () => {
+      expect(frequencyToCron('weekly', '09:00')).toBe('0 9 * * 1');
+    });
+
+    it('converts monthly to 1st of month', () => {
+      expect(frequencyToCron('monthly', '10:15')).toBe('15 10 1 * *');
+    });
+
+    it('defaults to 9:00 when no time given', () => {
+      expect(frequencyToCron('daily')).toBe('0 9 * * *');
+    });
+  });
+
+  describe('CRUD operations', () => {
+    it('creates a task', () => {
+      const task = engine.createTask({
+        name: 'Test Task',
+        schedule: '0 9 * * *',
+        description: 'Test description',
+        frequency: 'daily',
+        time: '09:00',
+        outputChannel: 'web',
+        enabled: true,
+      });
+      expect(task.id).toBeTruthy();
+      expect(task.name).toBe('Test Task');
+      expect(task.createdAt).toBeTruthy();
+    });
+
+    it('lists tasks', () => {
+      engine.createTask({ name: 'A', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
+      engine.createTask({ name: 'B', schedule: '0 10 * * *', description: '', frequency: 'daily', outputChannel: 'telegram', enabled: false });
+      const tasks = engine.listTasks();
+      expect(tasks.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('updates a task', () => {
+      const task = engine.createTask({ name: 'Original', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
+      const updated = engine.updateTask(task.id, { name: 'Updated', enabled: false });
+      expect(updated).not.toBeNull();
+      expect(updated!.name).toBe('Updated');
+      expect(updated!.enabled).toBe(false);
+    });
+
+    it('deletes a task', () => {
+      const task = engine.createTask({ name: 'ToDelete', schedule: '0 9 * * *', description: '', frequency: 'daily', outputChannel: 'web', enabled: true });
+      expect(engine.deleteTask(task.id)).toBe(true);
+      expect(engine.getTask(task.id)).toBeUndefined();
+    });
+
+    it('returns false for deleting non-existent task', () => {
+      expect(engine.deleteTask('nonexistent')).toBe(false);
+    });
+
+    it('returns null for updating non-existent task', () => {
+      expect(engine.updateTask('nonexistent', { name: 'x' })).toBeNull();
+    });
+  });
+
+  describe('run task', () => {
+    it('runs a task immediately', async () => {
+      const handler = vi.fn();
+      const eng = new CronEngine(handler);
+      const task = eng.createTask({ name: 'RunMe', schedule: '0 9 * * *', description: 'test', frequency: 'daily', outputChannel: 'web', enabled: true });
+      eng.start();
+      const result = await eng.runTask(task.id);
+      expect(result).toBe(true);
+      expect(handler).toHaveBeenCalled();
+      eng.stop();
+    });
+
+    it('returns false for running non-existent task', async () => {
+      const result = await engine.runTask('nonexistent');
+      expect(result).toBe(false);
+    });
+  });
+});

package/tests/daemon.test.ts

@@ -1,135 +1,135 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-describe('Daemon', () => {
-  const OPC_DIR_NAME = '.opc';
-  let tmpDir: string;
-  let opcDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'daemon-test-'));
-    opcDir = path.join(tmpDir, OPC_DIR_NAME);
-    fs.mkdirSync(opcDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  // Test the daemon's file-based contract (PID, heartbeat, log)
-  it('PID file can be created', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, '12345');
-    expect(fs.existsSync(pidFile)).toBe(true);
-    expect(fs.readFileSync(pidFile, 'utf-8')).toBe('12345');
-  });
-
-  it('PID file can be removed', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, '12345');
-    fs.unlinkSync(pidFile);
-    expect(fs.existsSync(pidFile)).toBe(false);
-  });
-
-  it('status: PID exists and process alive → running', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, String(process.pid)); // current process is alive
-    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8'));
-    let alive = false;
-    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
-    expect(alive).toBe(true);
-  });
-
-  it('status: no PID file → stopped', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    expect(fs.existsSync(pidFile)).toBe(false);
-  });
-
-  it('stale PID detection: PID file with non-running process', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, '999999999'); // very unlikely to be running
-    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8'));
-    let alive = false;
-    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
-    expect(alive).toBe(false);
-  });
-
-  it('heartbeat file written', () => {
-    const hbFile = path.join(opcDir, 'heartbeat');
-    const now = String(Date.now());
-    fs.writeFileSync(hbFile, now);
-    expect(fs.readFileSync(hbFile, 'utf-8')).toBe(now);
-  });
-
-  it('heartbeat staleness detection', () => {
-    const hbFile = path.join(opcDir, 'heartbeat');
-    const old = String(Date.now() - 120_000); // 2 minutes ago
-    fs.writeFileSync(hbFile, old);
-    const hbTime = parseInt(fs.readFileSync(hbFile, 'utf-8'));
-    expect(Date.now() - hbTime).toBeGreaterThan(60_000);
-  });
-
-  it('log file created', () => {
-    const logFile = path.join(opcDir, 'agent.log');
-    fs.writeFileSync(logFile, '[2026-04-18T10:00:00.000Z] Daemon started\n');
-    expect(fs.existsSync(logFile)).toBe(true);
-  });
-
-  it('log file appendable', () => {
-    const logFile = path.join(opcDir, 'agent.log');
-    fs.writeFileSync(logFile, 'line1\n');
-    fs.appendFileSync(logFile, 'line2\n');
-    const content = fs.readFileSync(logFile, 'utf-8');
-    expect(content).toContain('line1');
-    expect(content).toContain('line2');
-  });
-
-  it('double-start prevention: PID file already exists', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, String(process.pid));
-    // Simulating: check before starting
-    const exists = fs.existsSync(pidFile);
-    expect(exists).toBe(true);
-    // A real daemon would check and abort
-  });
-
-  it('started file tracks uptime', () => {
-    const startedFile = path.join(opcDir, 'started');
-    const startTime = Date.now();
-    fs.writeFileSync(startedFile, String(startTime));
-    const uptime = Date.now() - parseInt(fs.readFileSync(startedFile, 'utf-8'));
-    expect(uptime).toBeGreaterThanOrEqual(0);
-    expect(uptime).toBeLessThan(1000);
-  });
-
-  it('.opc directory creation is idempotent', () => {
-    fs.mkdirSync(opcDir, { recursive: true });
-    fs.mkdirSync(opcDir, { recursive: true }); // should not throw
-    expect(fs.existsSync(opcDir)).toBe(true);
-  });
-
-  it('graceful shutdown cleans up PID file', () => {
-    const pidFile = path.join(opcDir, 'agent.pid');
-    fs.writeFileSync(pidFile, '12345');
-    // Simulate shutdown
-    try { fs.unlinkSync(pidFile); } catch { /* ignore */ }
-    expect(fs.existsSync(pidFile)).toBe(false);
-  });
-
-  it('env file parsing', () => {
-    const envFile = path.join(tmpDir, '.env');
-    fs.writeFileSync(envFile, 'KEY1=value1\nKEY2=value2\n# comment\n');
-    const content = fs.readFileSync(envFile, 'utf-8');
-    const vars: Record<string, string> = {};
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith('#')) continue;
-      const eqIdx = trimmed.indexOf('=');
-      if (eqIdx === -1) continue;
-      vars[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim();
-    }
-    expect(vars).toEqual({ KEY1: 'value1', KEY2: 'value2' });
-  });
-});
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('Daemon', () => {
+  const OPC_DIR_NAME = '.opc';
+  let tmpDir: string;
+  let opcDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'daemon-test-'));
+    opcDir = path.join(tmpDir, OPC_DIR_NAME);
+    fs.mkdirSync(opcDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // Test the daemon's file-based contract (PID, heartbeat, log)
+  it('PID file can be created', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, '12345');
+    expect(fs.existsSync(pidFile)).toBe(true);
+    expect(fs.readFileSync(pidFile, 'utf-8')).toBe('12345');
+  });
+
+  it('PID file can be removed', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, '12345');
+    fs.unlinkSync(pidFile);
+    expect(fs.existsSync(pidFile)).toBe(false);
+  });
+
+  it('status: PID exists and process alive → running', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, String(process.pid)); // current process is alive
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8'));
+    let alive = false;
+    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
+    expect(alive).toBe(true);
+  });
+
+  it('status: no PID file → stopped', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    expect(fs.existsSync(pidFile)).toBe(false);
+  });
+
+  it('stale PID detection: PID file with non-running process', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, '999999999'); // very unlikely to be running
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf-8'));
+    let alive = false;
+    try { process.kill(pid, 0); alive = true; } catch { alive = false; }
+    expect(alive).toBe(false);
+  });
+
+  it('heartbeat file written', () => {
+    const hbFile = path.join(opcDir, 'heartbeat');
+    const now = String(Date.now());
+    fs.writeFileSync(hbFile, now);
+    expect(fs.readFileSync(hbFile, 'utf-8')).toBe(now);
+  });
+
+  it('heartbeat staleness detection', () => {
+    const hbFile = path.join(opcDir, 'heartbeat');
+    const old = String(Date.now() - 120_000); // 2 minutes ago
+    fs.writeFileSync(hbFile, old);
+    const hbTime = parseInt(fs.readFileSync(hbFile, 'utf-8'));
+    expect(Date.now() - hbTime).toBeGreaterThan(60_000);
+  });
+
+  it('log file created', () => {
+    const logFile = path.join(opcDir, 'agent.log');
+    fs.writeFileSync(logFile, '[2026-04-18T10:00:00.000Z] Daemon started\n');
+    expect(fs.existsSync(logFile)).toBe(true);
+  });
+
+  it('log file appendable', () => {
+    const logFile = path.join(opcDir, 'agent.log');
+    fs.writeFileSync(logFile, 'line1\n');
+    fs.appendFileSync(logFile, 'line2\n');
+    const content = fs.readFileSync(logFile, 'utf-8');
+    expect(content).toContain('line1');
+    expect(content).toContain('line2');
+  });
+
+  it('double-start prevention: PID file already exists', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, String(process.pid));
+    // Simulating: check before starting
+    const exists = fs.existsSync(pidFile);
+    expect(exists).toBe(true);
+    // A real daemon would check and abort
+  });
+
+  it('started file tracks uptime', () => {
+    const startedFile = path.join(opcDir, 'started');
+    const startTime = Date.now();
+    fs.writeFileSync(startedFile, String(startTime));
+    const uptime = Date.now() - parseInt(fs.readFileSync(startedFile, 'utf-8'));
+    expect(uptime).toBeGreaterThanOrEqual(0);
+    expect(uptime).toBeLessThan(1000);
+  });
+
+  it('.opc directory creation is idempotent', () => {
+    fs.mkdirSync(opcDir, { recursive: true });
+    fs.mkdirSync(opcDir, { recursive: true }); // should not throw
+    expect(fs.existsSync(opcDir)).toBe(true);
+  });
+
+  it('graceful shutdown cleans up PID file', () => {
+    const pidFile = path.join(opcDir, 'agent.pid');
+    fs.writeFileSync(pidFile, '12345');
+    // Simulate shutdown
+    try { fs.unlinkSync(pidFile); } catch { /* ignore */ }
+    expect(fs.existsSync(pidFile)).toBe(false);
+  });
+
+  it('env file parsing', () => {
+    const envFile = path.join(tmpDir, '.env');
+    fs.writeFileSync(envFile, 'KEY1=value1\nKEY2=value2\n# comment\n');
+    const content = fs.readFileSync(envFile, 'utf-8');
+    const vars: Record<string, string> = {};
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      const eqIdx = trimmed.indexOf('=');
+      if (eqIdx === -1) continue;
+      vars[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim();
+    }
+    expect(vars).toEqual({ KEY1: 'value1', KEY2: 'value2' });
+  });
+});