opc-agent 3.0.1 → 4.0.1

package/tests/home-assistant.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { haGetStates, haCallService, haGetHistory, haAutomation, configureHomeAssistant } from '../src/tools/builtin/home-assistant';
+
+describe('Home Assistant Tools', () => {
+  it('ha_get_states fails without config', async () => {
+    const r = await haGetStates.execute({});
+    expect(r.isError).toBe(true);
+    expect(r.content).toContain('not configured');
+  });
+
+  it('ha_call_service fails without config', async () => {
+    const r = await haCallService.execute({ domain: 'light', service: 'turn_on', entity_id: 'light.living' });
+    expect(r.isError).toBe(true);
+  });
+
+  it('ha_get_history fails without config', async () => {
+    const r = await haGetHistory.execute({ entity_id: 'sensor.temp' });
+    expect(r.isError).toBe(true);
+  });
+
+  it('ha_automation list fails without config', async () => {
+    const r = await haAutomation.execute({ action: 'list' });
+    expect(r.isError).toBe(true);
+  });
+
+  it('ha_automation requires automation_id for trigger', async () => {
+    configureHomeAssistant({ url: 'http://localhost:8123', token: 'test' });
+    // Will fail on fetch but tests the validation path
+    const r = await haAutomation.execute({ action: 'trigger' });
+    expect(r.isError).toBe(true);
+    expect(r.content).toContain('automation_id required');
+  });
+
+  it('all HA tools have correct names', () => {
+    expect(haGetStates.name).toBe('ha_get_states');
+    expect(haCallService.name).toBe('ha_call_service');
+    expect(haGetHistory.name).toBe('ha_get_history');
+    expect(haAutomation.name).toBe('ha_automation');
+  });
+});

package/tests/hooks.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from 'vitest';
+import { HookManager, ALL_HOOK_EVENTS } from '../src/core/hooks';
+import type { HookContext, HookEvent } from '../src/core/hooks';
+
+describe('HookManager', () => {
+  it('should have 14 hook events defined', () => {
+    // 7 before/after pairs (message/tool/llm/send/learn/recall) = 12 + on:error/start/stop = 15
+    expect(ALL_HOOK_EVENTS.length).toBe(15);
+  });
+
+  it('should register and run hooks', async () => {
+    const mgr = new HookManager();
+    let called = false;
+    mgr.register('before:message', () => { called = true; });
+    await mgr.run('before:message');
+    expect(called).toBe(true);
+  });
+
+  it('should run hooks in priority order', async () => {
+    const mgr = new HookManager();
+    const order: number[] = [];
+    mgr.register('before:tool', () => { order.push(2); }, { priority: 200 });
+    mgr.register('before:tool', () => { order.push(1); }, { priority: 50 });
+    mgr.register('before:tool', () => { order.push(3); }, { priority: 300 });
+    await mgr.run('before:tool');
+    expect(order).toEqual([1, 2, 3]);
+  });
+
+  it('should allow context modification', async () => {
+    const mgr = new HookManager();
+    mgr.register('before:llm', (ctx) => ({ ...ctx, modified: true }));
+    mgr.register('before:llm', (ctx) => ({ ...ctx, extra: 'data' }));
+    const result = await mgr.run('before:llm', { original: true });
+    expect(result.original).toBe(true);
+    expect(result.modified).toBe(true);
+    expect(result.extra).toBe('data');
+  });
+
+  it('should unregister hooks', async () => {
+    const mgr = new HookManager();
+    let count = 0;
+    const id = mgr.register('after:message', () => { count++; });
+    await mgr.run('after:message');
+    expect(count).toBe(1);
+    expect(mgr.unregister(id)).toBe(true);
+    await mgr.run('after:message');
+    expect(count).toBe(1);
+  });
+
+  it('should list registered hooks', () => {
+    const mgr = new HookManager();
+    mgr.register('on:error', () => {}, { name: 'error-logger', priority: 10 });
+    const list = mgr.getRegistered('on:error');
+    expect(list).toHaveLength(1);
+    expect(list[0].name).toBe('error-logger');
+    expect(list[0].priority).toBe(10);
+  });
+
+  it('should clear hooks', () => {
+    const mgr = new HookManager();
+    mgr.register('on:start', () => {});
+    mgr.register('on:stop', () => {});
+    mgr.clear('on:start');
+    expect(mgr.hasHooks('on:start')).toBe(false);
+    expect(mgr.hasHooks('on:stop')).toBe(true);
+    mgr.clear();
+    expect(mgr.hasHooks('on:stop')).toBe(false);
+  });
+
+  it('should handle async hooks', async () => {
+    const mgr = new HookManager();
+    mgr.register('before:send', async (ctx) => {
+      await new Promise(r => setTimeout(r, 5));
+      return { ...ctx, async: true };
+    });
+    const result = await mgr.run('before:send', {});
+    expect(result.async).toBe(true);
+  });
+});

package/tests/ide-bridge.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { IDEBridge } from '../src/core/ide-bridge';
+
+describe('IDEBridge', () => {
+  it('should create with vscode config', () => {
+    const bridge = new IDEBridge({ editor: 'vscode' });
+    expect(bridge).toBeInstanceOf(IDEBridge);
+  });
+
+  it('should create with jetbrains config', () => {
+    const bridge = new IDEBridge({ editor: 'jetbrains', workspacePath: '/tmp' });
+    expect(bridge).toBeInstanceOf(IDEBridge);
+  });
+
+  it('getDiagnostics returns empty array (stub)', async () => {
+    const bridge = new IDEBridge({ editor: 'vscode' });
+    const diags = await bridge.getDiagnostics();
+    expect(diags).toEqual([]);
+  });
+
+  it('getOpenFiles returns empty array (stub)', async () => {
+    const bridge = new IDEBridge({ editor: 'zed' });
+    const files = await bridge.getOpenFiles();
+    expect(files).toEqual([]);
+  });
+
+  it('getSelection returns null (stub)', async () => {
+    const bridge = new IDEBridge({ editor: 'cursor' });
+    const sel = await bridge.getSelection();
+    expect(sel).toBeNull();
+  });
+
+  it('applyEdit throws for non-empty edits (stub)', async () => {
+    const bridge = new IDEBridge({ editor: 'vscode' });
+    await expect(bridge.applyEdit('test.ts', [{ range: { startLine: 1, startColumn: 0, endLine: 1, endColumn: 5 }, newText: 'hi' }]))
+      .rejects.toThrow('extension');
+  });
+});

package/tests/image-generator.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ImageGenerator } from '../src/tools/image-generator';
+
+describe('ImageGenerator', () => {
+  describe('detectProvider', () => {
+    it('returns null when no keys configured', () => {
+      const gen = new ImageGenerator({});
+      expect(gen.detectProvider()).toBeNull();
+    });
+
+    it('detects dalle when openai key set', () => {
+      const gen = new ImageGenerator({ openaiApiKey: 'sk-test' });
+      expect(gen.detectProvider()).toBe('dalle');
+    });
+
+    it('detects stable-diffusion when SD URL set', () => {
+      const gen = new ImageGenerator({ sdApiUrl: 'http://localhost:7860' });
+      expect(gen.detectProvider()).toBe('stable-diffusion');
+    });
+
+    it('detects replicate when token set', () => {
+      const gen = new ImageGenerator({ replicateApiKey: 'r8_test' });
+      expect(gen.detectProvider()).toBe('replicate');
+    });
+
+    it('prefers dalle over others', () => {
+      const gen = new ImageGenerator({ openaiApiKey: 'sk-test', sdApiUrl: 'http://localhost:7860' });
+      expect(gen.detectProvider()).toBe('dalle');
+    });
+  });
+
+  describe('getStatus', () => {
+    it('returns provider status', () => {
+      const gen = new ImageGenerator({ openaiApiKey: 'sk-test' });
+      const status = gen.getStatus();
+      expect(status.configured).toBe(true);
+      expect(status.providers).toHaveLength(3);
+      expect(status.providers.find(p => p.name === 'dalle')?.configured).toBe(true);
+    });
+
+    it('shows unconfigured when no keys', () => {
+      const gen = new ImageGenerator({});
+      const status = gen.getStatus();
+      expect(status.configured).toBe(false);
+    });
+  });
+
+  describe('generate', () => {
+    it('returns error when no provider configured', async () => {
+      const gen = new ImageGenerator({});
+      const result = await gen.generate('a cat');
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('No image generation provider configured');
+    });
+
+    it('returns error for unknown provider', async () => {
+      const gen = new ImageGenerator({});
+      const result = await gen.generate('a cat', { provider: 'unknown' });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Unknown provider');
+    });
+
+    it('returns error when dalle key missing', async () => {
+      const gen = new ImageGenerator({});
+      const result = await gen.generate('a cat', { provider: 'dalle' });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('OPENAI_API_KEY');
+    });
+
+    it('returns error when SD URL missing', async () => {
+      const gen = new ImageGenerator({});
+      const result = await gen.generate('a cat', { provider: 'stable-diffusion' });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('SD_API_URL');
+    });
+
+    it('returns error when replicate key missing', async () => {
+      const gen = new ImageGenerator({});
+      const result = await gen.generate('a cat', { provider: 'replicate' });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('REPLICATE_API_TOKEN');
+    });
+  });
+});

package/tests/node-network.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { NodeNetwork } from '../src/core/node-network';
+
+describe('NodeNetwork', () => {
+  let network: NodeNetwork;
+
+  beforeEach(() => { network = new NodeNetwork(); });
+
+  it('should add a node', () => {
+    const node = network.addNode({ name: 'pi-1', type: 'pi', host: '192.168.1.10' });
+    expect(node.id).toBeTruthy();
+    expect(node.name).toBe('pi-1');
+    expect(network.listNodes().length).toBe(1);
+  });
+
+  it('should remove a node', () => {
+    const node = network.addNode({ name: 'test' });
+    network.removeNode(node.id);
+    expect(network.listNodes().length).toBe(0);
+  });
+
+  it('should throw on removing unknown node', () => {
+    expect(() => network.removeNode('unknown')).toThrow('not found');
+  });
+
+  it('should get node by id', () => {
+    const node = network.addNode({ name: 'desktop-1' });
+    expect(network.getNode(node.id)?.name).toBe('desktop-1');
+    expect(network.getNode('nonexistent')).toBeNull();
+  });
+
+  it('should pair a node', async () => {
+    const node = network.addNode({ name: 'phone', type: 'phone', status: 'pairing' });
+    const result = await network.pair(node.id, 'ABC123');
+    expect(result).toBe(true);
+    expect(network.getNode(node.id)?.status).toBe('online');
+  });
+
+  it('should fail pairing with short code', async () => {
+    const node = network.addNode({ name: 'phone', status: 'pairing' });
+    const result = await network.pair(node.id, 'ab');
+    expect(result).toBe(false);
+  });
+
+  it('should send command to online node', async () => {
+    const node = network.addNode({ name: 'vps', status: 'online' });
+    const result = await network.sendCommand(node.id, 'uptime');
+    expect(result.command).toBe('uptime');
+    expect(result.status).toBe('sent');
+  });
+
+  it('should throw sending to offline node', async () => {
+    const node = network.addNode({ name: 'offline', status: 'offline' });
+    await expect(network.sendCommand(node.id, 'test')).rejects.toThrow('offline');
+  });
+
+  it('should broadcast to online nodes', async () => {
+    network.addNode({ name: 'n1', status: 'online' });
+    network.addNode({ name: 'n2', status: 'online' });
+    network.addNode({ name: 'n3', status: 'offline' });
+    const results = await network.broadcast('ping');
+    expect(results.size).toBe(2);
+  });
+
+  it('should health check all nodes', async () => {
+    network.addNode({ name: 'up', status: 'online' });
+    network.addNode({ name: 'down', status: 'offline' });
+    const health = await network.healthCheck();
+    expect(health.size).toBe(2);
+    const vals = Array.from(health.values());
+    expect(vals).toContain(true);
+    expect(vals).toContain(false);
+  });
+});

package/tests/profiles.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ProfileManager } from '../src/core/profiles';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('ProfileManager', () => {
+  let tmpDir: string;
+  let pm: ProfileManager;
+
+  beforeEach(() => {
+    tmpDir = path.join(os.tmpdir(), `opc-profiles-test-${Date.now()}`);
+    pm = new ProfileManager(tmpDir);
+  });
+
+  afterEach(() => {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+
+  it('should create a profile', () => {
+    const p = pm.create('test-profile', { model: 'gpt-4o' });
+    expect(p.name).toBe('test-profile');
+    expect(p.config.model).toBe('gpt-4o');
+  });
+
+  it('should throw on duplicate create', () => {
+    pm.create('dup');
+    expect(() => pm.create('dup')).toThrow('already exists');
+  });
+
+  it('should list profiles', () => {
+    pm.create('a');
+    pm.create('b');
+    const list = pm.list();
+    expect(list).toHaveLength(2);
+    expect(list.map(p => p.name).sort()).toEqual(['a', 'b']);
+  });
+
+  it('should switch profiles', () => {
+    pm.create('prof1');
+    pm.create('prof2');
+    pm.switch('prof1');
+    expect(pm.current().name).toBe('prof1');
+    pm.switch('prof2');
+    expect(pm.current().name).toBe('prof2');
+  });
+
+  it('should delete a non-current profile', () => {
+    pm.create('keeper');
+    pm.create('goner');
+    pm.switch('keeper');
+    pm.delete('goner');
+    expect(pm.list()).toHaveLength(1);
+  });
+
+  it('should throw when deleting current profile', () => {
+    pm.create('active');
+    pm.switch('active');
+    expect(() => pm.delete('active')).toThrow('Cannot delete');
+  });
+});

package/tests/rl-tools.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  rlRecordTrajectory, rlEvaluateOutcome, rlGetBestStrategy, rlCompareStrategies,
+  rlGenerateTrainingData, rlRewardSignal, rlExplorationSuggest, rlUpdatePolicy,
+  rlGetStatistics, rlResetEpisode,
+} from '../src/tools/builtin/rl-tools';
+
+describe('RL Tools', () => {
+  beforeEach(async () => { await rlResetEpisode.execute({}); });
+
+  it('rl_record_trajectory records actions', async () => {
+    const r = await rlRecordTrajectory.execute({ taskType: 'search', action: 'web_search' });
+    const data = JSON.parse(r.content);
+    expect(data.episodeId).toBeTruthy();
+    expect(data.actionsRecorded).toBe(1);
+  });
+
+  it('rl_evaluate_outcome scores episode', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'search', action: 'web_search' });
+    const r = await rlEvaluateOutcome.execute({ outcome: 'success' });
+    const data = JSON.parse(r.content);
+    expect(data.score).toBe(1);
+  });
+
+  it('rl_get_best_strategy returns null when no data', async () => {
+    const r = await rlGetBestStrategy.execute({ taskType: 'nonexistent_xyz' });
+    expect(JSON.parse(r.content).strategy).toBeNull();
+  });
+
+  it('rl_compare_strategies returns breakdown', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'coding', action: 'write', outcome: 'success' });
+    await rlResetEpisode.execute({});
+    await rlRecordTrajectory.execute({ taskType: 'coding', action: 'debug', outcome: 'failure' });
+    const r = await rlCompareStrategies.execute({ taskType: 'coding' });
+    const data = JSON.parse(r.content);
+    expect(data.total).toBe(2);
+    expect(data.breakdown.successes).toBe(1);
+  });
+
+  it('rl_generate_training_data exports JSONL', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'test', action: 'action1', outcome: 'success' });
+    const r = await rlGenerateTrainingData.execute({ taskType: 'test' });
+    expect(r.content).toContain('action1');
+  });
+
+  it('rl_reward_signal records reward', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'test', action: 'act' });
+    const r = await rlRewardSignal.execute({ reward: 1.5 });
+    const data = JSON.parse(r.content);
+    expect(data.reward).toBe(1.5);
+    expect(data.totalReward).toBe(1.5);
+  });
+
+  it('rl_reward_signal fails without episode', async () => {
+    const r = await rlRewardSignal.execute({ reward: 1 });
+    expect(r.isError).toBe(true);
+  });
+
+  it('rl_exploration_suggest returns suggestions', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'explore', action: 'a' });
+    await rlResetEpisode.execute({});
+    await rlRecordTrajectory.execute({ taskType: 'explore', action: 'b' });
+    const r = await rlExplorationSuggest.execute({ taskType: 'explore', currentAction: 'a' });
+    const data = JSON.parse(r.content);
+    expect(data.suggestions).toContain('b');
+  });
+
+  it('rl_update_policy updates weights', async () => {
+    const r = await rlUpdatePolicy.execute({ taskType: 'code', action: 'refactor', weight: 2 });
+    const data = JSON.parse(r.content);
+    expect(data.weights.refactor).toBe(2);
+  });
+
+  it('rl_get_statistics returns stats', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'stats_test', action: 'a', outcome: 'success' });
+    const r = await rlGetStatistics.execute({ taskType: 'stats_test' });
+    const data = JSON.parse(r.content);
+    expect(data.stats_test.total).toBe(1);
+    expect(data.stats_test.success).toBe(1);
+  });
+
+  it('rl_reset_episode clears state', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'test', action: 'a' });
+    const r = await rlResetEpisode.execute({});
+    expect(JSON.parse(r.content).hadActiveEpisode).toBe(true);
+  });
+
+  it('trajectory recording accumulates actions', async () => {
+    await rlRecordTrajectory.execute({ taskType: 'multi', action: 'step1' });
+    const r = await rlRecordTrajectory.execute({ taskType: 'multi', action: 'step2' });
+    expect(JSON.parse(r.content).actionsRecorded).toBe(2);
+  });
+});

package/tests/sandbox-manager.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { SandboxManager } from '../src/core/sandbox';
+
+describe('SandboxManager (Remote)', () => {
+  it('should create with default local backend', () => {
+    const sm = new SandboxManager();
+    expect(sm).toBeDefined();
+  });
+
+  it('should exec local command', async () => {
+    const sm = new SandboxManager({ backend: 'local' });
+    const result = await sm.exec('echo hello');
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('hello');
+  });
+
+  it('should return non-zero exit code on failure', async () => {
+    const sm = new SandboxManager({ backend: 'local' });
+    const result = await sm.exec('exit 1');
+    expect(result.exitCode).not.toBe(0);
+  });
+
+  it('should throw on docker without image', async () => {
+    const sm = new SandboxManager({ backend: 'docker' });
+    await expect(sm.exec('echo hi')).rejects.toThrow('Docker image is required');
+  });
+
+  it('should throw on ssh without host', async () => {
+    const sm = new SandboxManager({ backend: 'ssh' });
+    await expect(sm.exec('echo hi')).rejects.toThrow('SSH host and user are required');
+  });
+
+  it('should upload locally (copy)', async () => {
+    const sm = new SandboxManager({ backend: 'local' });
+    const fs = await import('fs');
+    const path = await import('path');
+    const os = await import('os');
+    const src = path.join(os.tmpdir(), 'sandbox-test-src.txt');
+    const dst = path.join(os.tmpdir(), 'sandbox-test-dst.txt');
+    fs.writeFileSync(src, 'test content');
+    await sm.upload(src, dst);
+    expect(fs.readFileSync(dst, 'utf-8')).toBe('test content');
+    fs.unlinkSync(src);
+    fs.unlinkSync(dst);
+  });
+});

package/tests/secrets.test.ts

@@ -0,0 +1,107 @@
+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');
+  });
+});