opc-agent 2.0.0 → 2.0.1

package/tests/mcp-server.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MCPServer } from '../src/protocols/mcp/server';
+import { agentToMCPTools, agentToMCPResources } from '../src/protocols/mcp/agent-tools';
+import type { MCPServerToolDefinition, JsonRpcRequest } from '../src/protocols/mcp/types';
+
+function makeRequest(method: string, params?: any, id: number = 1): JsonRpcRequest {
+  return { jsonrpc: '2.0', id, method, params };
+}
+
+describe('MCPServer', () => {
+  let server: MCPServer;
+  const echoTool: MCPServerToolDefinition = {
+    name: 'echo',
+    description: 'Echo back input',
+    inputSchema: {
+      type: 'object',
+      properties: { text: { type: 'string' } },
+      required: ['text'],
+    },
+    handler: async (args) => `Echo: ${args.text}`,
+  };
+
+  beforeEach(() => {
+    server = new MCPServer({ name: 'test-server', version: '1.0.0', tools: [echoTool] });
+  });
+
+  it('initialize response has capabilities', async () => {
+    const res = await server.handleMessage(makeRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'test', version: '1.0' },
+    }));
+    expect(res).toBeDefined();
+    expect(res!.result.protocolVersion).toBe('2024-11-05');
+    expect(res!.result.capabilities.tools).toBeDefined();
+    expect(res!.result.serverInfo.name).toBe('test-server');
+  });
+
+  it('tools/list returns registered tools', async () => {
+    const res = await server.handleMessage(makeRequest('tools/list'));
+    expect(res!.result.tools).toHaveLength(1);
+    expect(res!.result.tools[0].name).toBe('echo');
+    expect(res!.result.tools[0].description).toBe('Echo back input');
+    expect(res!.result.tools[0].inputSchema).toBeDefined();
+  });
+
+  it('tools/call executes handler and returns content', async () => {
+    const res = await server.handleMessage(makeRequest('tools/call', {
+      name: 'echo', arguments: { text: 'hello' },
+    }));
+    expect(res!.result.content).toHaveLength(1);
+    expect(res!.result.content[0].text).toBe('Echo: hello');
+  });
+
+  it('tools/call returns error for missing tool', async () => {
+    const res = await server.handleMessage(makeRequest('tools/call', {
+      name: 'nonexistent', arguments: {},
+    }));
+    expect(res!.error).toBeDefined();
+    expect(res!.error!.code).toBe(-32001);
+  });
+
+  it('tools/call validates required params', async () => {
+    const res = await server.handleMessage(makeRequest('tools/call', {
+      name: 'echo', arguments: {},
+    }));
+    expect(res!.error).toBeDefined();
+    expect(res!.error!.code).toBe(-32602);
+    expect(res!.error!.message).toContain('text');
+  });
+
+  it('resources/list returns registered resources', async () => {
+    server.addResource({
+      uri: 'test://doc', name: 'TestDoc', description: 'A doc', mimeType: 'text/plain',
+      handler: async () => 'Hello content',
+    });
+    const res = await server.handleMessage(makeRequest('resources/list'));
+    expect(res!.result.resources).toHaveLength(1);
+    expect(res!.result.resources[0].uri).toBe('test://doc');
+  });
+
+  it('resources/read returns resource content', async () => {
+    server.addResource({
+      uri: 'test://doc', name: 'TestDoc', mimeType: 'text/plain',
+      handler: async () => 'Hello content',
+    });
+    const res = await server.handleMessage(makeRequest('resources/read', { uri: 'test://doc' }));
+    expect(res!.result.contents[0].text).toBe('Hello content');
+  });
+
+  it('resources/read returns error for unknown resource', async () => {
+    const res = await server.handleMessage(makeRequest('resources/read', { uri: 'nope://x' }));
+    expect(res!.error).toBeDefined();
+    expect(res!.error!.code).toBe(-32002);
+  });
+
+  it('unknown method returns METHOD_NOT_FOUND', async () => {
+    const res = await server.handleMessage(makeRequest('foo/bar'));
+    expect(res!.error).toBeDefined();
+    expect(res!.error!.code).toBe(-32601);
+  });
+
+  it('JSON-RPC format: response has jsonrpc 2.0 and matching id', async () => {
+    const res = await server.handleMessage(makeRequest('tools/list', {}, 42));
+    expect(res!.jsonrpc).toBe('2.0');
+    expect(res!.id).toBe(42);
+  });
+
+  it('notification (no id) returns null', async () => {
+    const res = await server.handleMessage({
+      jsonrpc: '2.0', method: 'notifications/initialized', params: {},
+    } as any);
+    expect(res).toBeNull();
+  });
+
+  it('prompts/list returns prompts', async () => {
+    server.addPrompt({
+      name: 'summarize', description: 'Summarize text',
+      arguments: [{ name: 'text', required: true }],
+    });
+    const res = await server.handleMessage(makeRequest('prompts/list'));
+    expect(res!.result.prompts).toHaveLength(1);
+    expect(res!.result.prompts[0].name).toBe('summarize');
+  });
+
+  it('addTool/removeTool works dynamically', () => {
+    expect(server.getToolCount()).toBe(1);
+    server.addTool({ name: 'test2', description: 't', inputSchema: {}, handler: async () => 'ok' });
+    expect(server.getToolCount()).toBe(2);
+    server.removeTool('test2');
+    expect(server.getToolCount()).toBe(1);
+  });
+});
+
+describe('agentToMCPTools', () => {
+  it('generates correct tools from agent', () => {
+    const agent = { name: 'test-agent' };
+    const tools = agentToMCPTools(agent);
+    expect(tools.length).toBeGreaterThanOrEqual(3);
+    const names = tools.map(t => t.name);
+    expect(names).toContain('chat');
+    expect(names).toContain('memory_search');
+    expect(names).toContain('memory_store');
+  });
+
+  it('chat tool has correct schema', () => {
+    const tools = agentToMCPTools({ name: 'bot' });
+    const chat = tools.find(t => t.name === 'chat')!;
+    expect(chat.inputSchema.required).toContain('message');
+    expect(chat.description).toContain('bot');
+  });
+
+  it('exposes agent skills as tools', () => {
+    const agent = {
+      name: 'skilled',
+      skills: [{ name: 'translate', description: 'Translate text', execute: async () => 'done' }],
+    };
+    const tools = agentToMCPTools(agent);
+    const skillTool = tools.find(t => t.name === 'skill_translate');
+    expect(skillTool).toBeDefined();
+    expect(skillTool!.description).toContain('Translate');
+  });
+});
+
+describe('agentToMCPResources', () => {
+  it('returns empty array for non-existent dir', () => {
+    const resources = agentToMCPResources({}, '/tmp/nonexistent-agent-dir-xyz');
+    expect(resources).toEqual([]);
+  });
+
+  it('exposes agent files that exist', () => {
+    // Use current project dir which has files
+    const path = require('path');
+    const resources = agentToMCPResources({}, path.resolve(__dirname, '..'));
+    // At minimum no crash; might find some files
+    expect(Array.isArray(resources)).toBe(true);
+  });
+});

package/tests/plugin-a2a-enhanced.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PluginManager } from '../src/plugins';
+import type { Plugin } from '../src/plugins';
+import { loggerPlugin } from '../src/plugins/logger';
+import { rateLimiterPlugin, createRateLimiterPlugin } from '../src/plugins/rate-limiter';
+import { contentFilterPlugin, createContentFilterPlugin } from '../src/plugins/content-filter';
+import { AgentCardRegistry } from '../src/core/a2a';
+import type { AgentCard } from '../src/core/a2a';
+
+// ── PluginManager Enhanced Tests ────────────────────────────
+
+describe('PluginManager (enhanced middleware)', () => {
+  let pm: PluginManager;
+
+  beforeEach(() => {
+    pm = new PluginManager();
+  });
+
+  it('should register and list enhanced plugins', () => {
+    const p: Plugin = { name: 'test', version: '1.0.0' };
+    pm.registerEnhanced(p);
+    expect(pm.has('test')).toBe(true);
+    expect(pm.listEnhanced()).toHaveLength(1);
+  });
+
+  it('should unregister enhanced plugins', () => {
+    pm.registerEnhanced({ name: 'tmp', version: '1.0.0' });
+    pm.unregisterEnhanced('tmp');
+    expect(pm.getEnhanced('tmp')).toBeUndefined();
+  });
+
+  it('should get enhanced plugin by name', () => {
+    pm.registerEnhanced({ name: 'foo', version: '2.0.0' });
+    expect(pm.getEnhanced('foo')?.version).toBe('2.0.0');
+  });
+
+  it('should run message middleware chain in order', async () => {
+    const order: number[] = [];
+    pm.registerEnhanced({
+      name: 'p1', version: '1.0.0',
+      onMessage: async (msg, next) => { order.push(1); return next({ ...msg, p1: true }); },
+    });
+    pm.registerEnhanced({
+      name: 'p2', version: '1.0.0',
+      onMessage: async (msg, next) => { order.push(2); return next({ ...msg, p2: true }); },
+    });
+
+    const result = await pm.runMessageMiddleware({ content: 'hi' });
+    expect(order).toEqual([1, 2]);
+    expect(result.p1).toBe(true);
+    expect(result.p2).toBe(true);
+  });
+
+  it('should run response middleware chain', async () => {
+    pm.registerEnhanced({
+      name: 'r1', version: '1.0.0',
+      onResponse: async (res, next) => next({ ...res, tagged: true }),
+    });
+
+    const result = await pm.runResponseMiddleware({ content: 'reply' });
+    expect(result.tagged).toBe(true);
+  });
+
+  it('should pass through when no middleware registered', async () => {
+    const msg = { content: 'hello' };
+    const result = await pm.runMessageMiddleware(msg);
+    expect(result).toEqual(msg);
+  });
+
+  it('middleware can short-circuit by not calling next', async () => {
+    pm.registerEnhanced({
+      name: 'blocker', version: '1.0.0',
+      onMessage: async (_msg, _next) => ({ content: 'blocked' }),
+    });
+    pm.registerEnhanced({
+      name: 'never', version: '1.0.0',
+      onMessage: async (msg, next) => { throw new Error('should not reach'); },
+    });
+
+    const result = await pm.runMessageMiddleware({ content: 'test' });
+    expect(result.content).toBe('blocked');
+  });
+
+  it('initAll calls onInit for enhanced plugins', async () => {
+    const inited: string[] = [];
+    pm.registerEnhanced({
+      name: 'init-test', version: '1.0.0',
+      onInit: async () => { inited.push('init-test'); },
+    });
+    await pm.initAll({});
+    expect(inited).toContain('init-test');
+  });
+
+  it('shutdownAll calls onShutdown for enhanced plugins', async () => {
+    const shutdown: string[] = [];
+    pm.registerEnhanced({
+      name: 'sd-test', version: '1.0.0',
+      onShutdown: async () => { shutdown.push('sd-test'); },
+    });
+    await pm.shutdownAll();
+    expect(shutdown).toContain('sd-test');
+  });
+
+  it('list() includes both legacy and enhanced plugins', () => {
+    pm.register({ name: 'legacy', version: '1.0.0' });
+    pm.registerEnhanced({ name: 'enhanced', version: '1.0.0' });
+    expect(pm.list()).toHaveLength(2);
+  });
+});
+
+// ── Built-in Plugin Tests ───────────────────────────────────
+
+describe('loggerPlugin', () => {
+  it('should log and pass through messages', async () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const msg = { content: 'hello world' };
+    const result = await loggerPlugin.onMessage!(msg, async (m) => m);
+    expect(spy).toHaveBeenCalled();
+    expect(result.content).toBe('hello world');
+    spy.mockRestore();
+  });
+
+  it('should log and pass through responses', async () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const res = { content: 'response text' };
+    const result = await loggerPlugin.onResponse!(res, async (r) => r);
+    expect(spy).toHaveBeenCalled();
+    expect(result.content).toBe('response text');
+    spy.mockRestore();
+  });
+});
+
+describe('rateLimiterPlugin', () => {
+  it('should allow messages under limit', async () => {
+    const plugin = createRateLimiterPlugin(5);
+    const msg = { content: 'test', id: 'session-1' };
+    for (let i = 0; i < 5; i++) {
+      await plugin.onMessage!(msg, async (m) => m);
+    }
+  });
+
+  it('should reject messages over limit', async () => {
+    const plugin = createRateLimiterPlugin(2);
+    const msg = { content: 'test', id: 'session-rl' };
+    await plugin.onMessage!(msg, async (m) => m);
+    await plugin.onMessage!(msg, async (m) => m);
+    await expect(plugin.onMessage!(msg, async (m) => m)).rejects.toThrow('Rate limit exceeded');
+  });
+});
+
+describe('contentFilterPlugin', () => {
+  it('should pass clean messages', async () => {
+    const plugin = createContentFilterPlugin(['spam', 'abuse']);
+    const result = await plugin.onMessage!({ content: 'hello' }, async (m) => m);
+    expect(result.content).toBe('hello');
+  });
+
+  it('should block messages with blocked words', async () => {
+    const plugin = createContentFilterPlugin(['spam']);
+    await expect(
+      plugin.onMessage!({ content: 'this is spam' }, async (m) => m)
+    ).rejects.toThrow('Content blocked');
+  });
+});
+
+// ── AgentCardRegistry Tests ─────────────────────────────────
+
+describe('AgentCardRegistry', () => {
+  let registry: AgentCardRegistry;
+
+  beforeEach(() => {
+    registry = new AgentCardRegistry();
+  });
+
+  it('should register and list agent cards', () => {
+    registry.register({ name: 'bot', description: 'A bot', capabilities: ['chat'] });
+    expect(registry.list()).toHaveLength(1);
+  });
+
+  it('should unregister agent cards', () => {
+    registry.register({ name: 'tmp', description: 'Temp', capabilities: [] });
+    registry.unregister('tmp');
+    expect(registry.list()).toHaveLength(0);
+  });
+
+  it('should get agent by name', () => {
+    registry.register({ name: 'a1', description: 'Agent 1', capabilities: [] });
+    expect(registry.get('a1')?.name).toBe('a1');
+    expect(registry.get('missing')).toBeUndefined();
+  });
+
+  it('should find by name', () => {
+    registry.register({ name: 'search-bot', description: 'Searches', capabilities: ['search'] });
+    registry.register({ name: 'chat-bot', description: 'Chats', capabilities: ['chat'] });
+    expect(registry.find('search')).toHaveLength(1);
+    expect(registry.find('search')[0].name).toBe('search-bot');
+  });
+
+  it('should find by capability', () => {
+    registry.register({ name: 'translator', description: 'Translates', capabilities: ['translate', 'detect-lang'] });
+    const found = registry.find('translate');
+    expect(found).toHaveLength(1);
+    expect(found[0].name).toBe('translator');
+  });
+
+  it('should find by description', () => {
+    registry.register({ name: 'x', description: 'Summarizes documents', capabilities: [] });
+    expect(registry.find('summarize')).toHaveLength(1);
+  });
+
+  it('should send to local handler', async () => {
+    registry.register({
+      name: 'echo',
+      description: 'Echo agent',
+      capabilities: ['echo'],
+      handler: async (msg) => `echo: ${msg}`,
+    });
+    const result = await registry.send('echo', 'hello');
+    expect(result).toBe('echo: hello');
+  });
+
+  it('should throw when sending to unknown agent', async () => {
+    await expect(registry.send('ghost', 'hi')).rejects.toThrow("Agent 'ghost' not found");
+  });
+
+  it('should throw when agent has no handler or endpoint', async () => {
+    registry.register({ name: 'empty', description: 'No handler', capabilities: [] });
+    await expect(registry.send('empty', 'hi')).rejects.toThrow('has no handler or endpoint');
+  });
+});

package/tests/publish.test.ts

@@ -0,0 +1,231 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+import { AgentPackager, AgentPublisher, AgentInstaller } from '../src/publish';
+
+function makeTempDir(): string {
+  const dir = path.join(os.tmpdir(), `opc-test-${crypto.randomBytes(6).toString('hex')}`);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function writeAgentYaml(dir: string, overrides: Record<string, any> = {}) {
+  const config = {
+    apiVersion: 'opc/v1',
+    kind: 'Agent',
+    metadata: { name: 'test-agent', version: '1.0.0', description: 'Test agent', author: 'Test', license: 'MIT', ...overrides.metadata },
+    spec: { model: 'gpt-4', provider: { default: 'openai' }, channels: [{ type: 'web' }], skills: [{ name: 'echo' }], tools: [], ...overrides.spec },
+  };
+  const yaml = require('js-yaml');
+  fs.writeFileSync(path.join(dir, 'agent.yaml'), yaml.dump(config));
+}
+
+function writePackageJson(dir: string, overrides: Record<string, any> = {}) {
+  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: 'test-agent', version: '1.0.0', ...overrides }, null, 2));
+}
+
+function setupValidProject(dir: string) {
+  writeAgentYaml(dir);
+  writePackageJson(dir);
+  fs.writeFileSync(path.join(dir, 'SOUL.md'), '# Soul');
+  fs.writeFileSync(path.join(dir, 'README.md'), '# Readme');
+  fs.writeFileSync(path.join(dir, 'src.ts'), 'console.log("hello")');
+}
+
+describe('AgentPackager', () => {
+  let tmpDir: string;
+  const packager = new AgentPackager();
+
+  beforeEach(() => { tmpDir = makeTempDir(); });
+  afterEach(() => { fs.rmSync(tmpDir, { recursive: true, force: true }); });
+
+  // 1. validate: missing agent.yaml → error
+  it('validate: missing agent.yaml produces error', async () => {
+    writePackageJson(tmpDir);
+    const result = await packager.validate(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing agent.yaml');
+  });
+
+  // 2. validate: missing package.json → error
+  it('validate: missing package.json produces error', async () => {
+    writeAgentYaml(tmpDir);
+    const result = await packager.validate(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Missing package.json');
+  });
+
+  // 3. validate: valid project → no errors
+  it('validate: valid project has no errors', async () => {
+    setupValidProject(tmpDir);
+    const result = await packager.validate(tmpDir);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  // 4. validate: missing SOUL.md → warning
+  it('validate: missing SOUL.md produces warning', async () => {
+    writeAgentYaml(tmpDir);
+    writePackageJson(tmpDir);
+    const result = await packager.validate(tmpDir);
+    expect(result.warnings).toContain('Missing SOUL.md (recommended)');
+  });
+
+  // 5. validate: missing README.md → warning
+  it('validate: missing README.md produces warning', async () => {
+    writeAgentYaml(tmpDir);
+    writePackageJson(tmpDir);
+    const result = await packager.validate(tmpDir);
+    expect(result.warnings).toContain('Missing README.md');
+  });
+
+  // 6. validate: uppercase name → error
+  it('validate: uppercase name in agent.yaml produces error', async () => {
+    writeAgentYaml(tmpDir, { metadata: { name: 'MyAgent', version: '1.0.0' } });
+    writePackageJson(tmpDir);
+    const result = await packager.validate(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('lowercase'))).toBe(true);
+  });
+
+  // 7. validate: invalid version → error
+  it('validate: invalid version format produces error', async () => {
+    writeAgentYaml(tmpDir, { metadata: { name: 'test', version: 'bad' } });
+    writePackageJson(tmpDir);
+    const result = await packager.validate(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('version'))).toBe(true);
+  });
+
+  // 8. listFiles: excludes node_modules
+  it('listFiles: excludes node_modules', async () => {
+    setupValidProject(tmpDir);
+    fs.mkdirSync(path.join(tmpDir, 'node_modules', 'foo'), { recursive: true });
+    fs.writeFileSync(path.join(tmpDir, 'node_modules', 'foo', 'index.js'), '');
+    const files = await packager.listFiles(tmpDir);
+    expect(files.every(f => !f.includes('node_modules'))).toBe(true);
+  });
+
+  // 9. listFiles: excludes .env
+  it('listFiles: excludes .env', async () => {
+    setupValidProject(tmpDir);
+    fs.writeFileSync(path.join(tmpDir, '.env'), 'SECRET=x');
+    const files = await packager.listFiles(tmpDir);
+    expect(files).not.toContain('.env');
+  });
+
+  // 10. listFiles: excludes .git
+  it('listFiles: excludes .git directory', async () => {
+    setupValidProject(tmpDir);
+    fs.mkdirSync(path.join(tmpDir, '.git'), { recursive: true });
+    fs.writeFileSync(path.join(tmpDir, '.git', 'config'), '');
+    const files = await packager.listFiles(tmpDir);
+    expect(files.every(f => !f.includes('.git'))).toBe(true);
+  });
+
+  // 11. listFiles: respects .opcignore
+  it('listFiles: respects .opcignore', async () => {
+    setupValidProject(tmpDir);
+    fs.writeFileSync(path.join(tmpDir, 'secret.txt'), 'hidden');
+    fs.writeFileSync(path.join(tmpDir, '.opcignore'), 'secret.txt\n');
+    const files = await packager.listFiles(tmpDir);
+    expect(files).not.toContain('secret.txt');
+  });
+
+  // 12. pack: creates .opc.tgz file
+  it('pack: creates .opc.tgz file', async () => {
+    setupValidProject(tmpDir);
+    const result = await packager.pack(tmpDir);
+    expect(fs.existsSync(result.path)).toBe(true);
+    expect(result.path).toMatch(/\.opc\.tgz$/);
+    // cleanup
+    fs.unlinkSync(result.path);
+  });
+
+  // 13. pack: manifest contains correct fields
+  it('pack: manifest contains correct fields', async () => {
+    setupValidProject(tmpDir);
+    const result = await packager.pack(tmpDir);
+    expect(result.manifest.name).toBe('test-agent');
+    expect(result.manifest.version).toBe('1.0.0');
+    expect(result.manifest.author).toBe('Test');
+    expect(result.manifest.license).toBe('MIT');
+    expect(result.manifest.agent.model).toBe('gpt-4');
+    expect(result.manifest.agent.provider).toBe('openai');
+    expect(result.manifest.agent.channels).toContain('web');
+    expect(result.manifest.files.length).toBeGreaterThan(0);
+    expect(result.manifest.checksum).toBeTruthy();
+    expect(result.manifest.createdAt).toBeTruthy();
+    fs.unlinkSync(result.path);
+  });
+
+  // 14. manifest checksum is valid sha256
+  it('pack: checksum is valid sha256', async () => {
+    setupValidProject(tmpDir);
+    const result = await packager.pack(tmpDir);
+    expect(result.manifest.checksum).toMatch(/^[a-f0-9]{64}$/);
+    // Verify checksum matches file
+    const fileHash = crypto.createHash('sha256').update(fs.readFileSync(result.path)).digest('hex');
+    expect(result.manifest.checksum).toBe(fileHash);
+    fs.unlinkSync(result.path);
+  });
+
+  // 15. pack: validation failure throws
+  it('pack: throws on invalid project', async () => {
+    // Empty dir — no agent.yaml
+    await expect(packager.pack(tmpDir)).rejects.toThrow('Validation failed');
+  });
+});
+
+describe('AgentPublisher', () => {
+  // 16. dry-run doesn't throw
+  it('dry-run returns success without error', async () => {
+    const publisher = new AgentPublisher();
+    const manifest = {
+      name: 'test', version: '1.0.0', description: '', author: '', license: 'MIT',
+      agent: { model: '', provider: '', channels: [], skills: [], tools: [] },
+      files: ['a.ts'], checksum: 'abc', createdAt: new Date().toISOString(),
+    };
+    const result = await publisher.publish('/fake/path.opc.tgz', manifest, { dryRun: true });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('AgentInstaller', () => {
+  let tmpDir: string;
+  let installDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTempDir();
+    installDir = makeTempDir();
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(installDir, { recursive: true, force: true });
+  });
+
+  // 17. install from tarball extracts correctly
+  it('install from .opc.tgz extracts files', async () => {
+    // Create a valid project and pack it
+    setupValidProject(tmpDir);
+    const packager = new AgentPackager();
+    const { path: pkgPath } = await packager.pack(tmpDir);
+
+    const installer = new AgentInstaller();
+    await installer.install(pkgPath, installDir);
+
+    // Check that files were extracted
+    const extractedFiles = fs.readdirSync(installDir);
+    expect(extractedFiles.length).toBeGreaterThan(0);
+
+    fs.unlinkSync(pkgPath);
+  });
+
+  // 18. install from missing file throws
+  it('install from missing file throws', async () => {
+    const installer = new AgentInstaller();
+    await expect(installer.install('/nonexistent/pkg.opc.tgz', installDir)).rejects.toThrow();
+  });
+});