opc-agent 4.1.1 → 4.1.3

package/tests/publish.test.ts

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

package/tests/rl-tools.test.ts

@@ -1,93 +0,0 @@
-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/room.test.ts

@@ -1,106 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Room } from '../src/core/room';
-import { BaseAgent } from '../src/core/agent';
-
-function makeAgent(name: string): BaseAgent {
-  const agent = new BaseAgent({ name });
-  // Synchronously set to ready by calling init
-  return agent;
-}
-
-describe('Room System', () => {
-  it('should create a room with a name', () => {
-    const room = new Room('test-room');
-    expect(room.name).toBe('test-room');
-    expect(room.getAgents()).toEqual([]);
-  });
-
-  it('should add and remove agents', () => {
-    const room = new Room('office');
-    const agent = makeAgent('agent-1');
-    room.addAgent(agent);
-    expect(room.getAgents()).toEqual(['agent-1']);
-    room.removeAgent('agent-1');
-    expect(room.getAgents()).toEqual([]);
-  });
-
-  it('should emit events on join/leave', () => {
-    const room = new Room('office');
-    const events: string[] = [];
-    room.on('agent:join', (name) => events.push(`join:${name}`));
-    room.on('agent:leave', (name) => events.push(`leave:${name}`));
-
-    const agent = makeAgent('a1');
-    room.addAgent(agent);
-    room.removeAgent('a1');
-    expect(events).toEqual(['join:a1', 'leave:a1']);
-  });
-
-  it('should support topic subscriptions', () => {
-    const room = new Room('office');
-    room.subscribe('agent-1', 'alerts');
-    room.subscribe('agent-2', 'alerts');
-    expect(room.getSubscribers('alerts')).toEqual(['agent-1', 'agent-2']);
-    room.unsubscribe('agent-1', 'alerts');
-    expect(room.getSubscribers('alerts')).toEqual(['agent-2']);
-  });
-
-  it('should broadcast to all agents except sender', async () => {
-    const room = new Room('office');
-    const a1 = makeAgent('a1');
-    const a2 = makeAgent('a2');
-    await a1.init();
-    await a2.init();
-    room.addAgent(a1);
-    room.addAgent(a2);
-
-    const responses = await room.broadcast('a1', 'Hello everyone');
-    expect(responses.length).toBe(1); // only a2 responds
-    expect(responses[0].role).toBe('assistant');
-  });
-
-  it('should send direct messages', async () => {
-    const room = new Room('office');
-    const a1 = makeAgent('a1');
-    const a2 = makeAgent('a2');
-    await a1.init();
-    await a2.init();
-    room.addAgent(a1);
-    room.addAgent(a2);
-
-    const responses = await room.send({
-      from: 'a1',
-      to: 'a2',
-      message: { id: 'm1', role: 'user', content: 'Hi a2', timestamp: Date.now() },
-    });
-    expect(responses.length).toBe(1);
-  });
-
-  it('should publish to topic subscribers only', async () => {
-    const room = new Room('office');
-    const a1 = makeAgent('a1');
-    const a2 = makeAgent('a2');
-    const a3 = makeAgent('a3');
-    await a1.init();
-    await a2.init();
-    await a3.init();
-    room.addAgent(a1);
-    room.addAgent(a2);
-    room.addAgent(a3);
-
-    room.subscribe('a2', 'alerts');
-    // a3 not subscribed
-    const responses = await room.publishToTopic('a1', 'alerts', 'Alert!');
-    expect(responses.length).toBe(1);
-  });
-
-  it('should remove agent from subscriptions on leave', () => {
-    const room = new Room('office');
-    room.subscribe('a1', 'topic1');
-    room.subscribe('a1', 'topic2');
-    expect(room.getSubscribers('topic1')).toContain('a1');
-    room.removeAgent('a1');
-    expect(room.getSubscribers('topic1')).not.toContain('a1');
-    expect(room.getSubscribers('topic2')).not.toContain('a1');
-  });
-});

package/tests/runtime.test.ts

@@ -1,42 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { AgentRuntime } from '../src/core/runtime';
-import { createCustomerServiceConfig } from '../src/templates/customer-service';
-
-describe('AgentRuntime', () => {
-  it('should initialize from config object', async () => {
-    const runtime = new AgentRuntime();
-    const config = createCustomerServiceConfig();
-    const agent = await runtime.initialize(config);
-    expect(agent.name).toBe('customer-service');
-    expect(agent.state).toBe('ready');
-  });
-
-  it('should throw if no config loaded', async () => {
-    const runtime = new AgentRuntime();
-    await expect(runtime.initialize()).rejects.toThrow('No config loaded');
-  });
-
-  it('should register skills after initialization', async () => {
-    const runtime = new AgentRuntime();
-    const config = createCustomerServiceConfig();
-    await runtime.initialize(config);
-
-    runtime.registerSkill({
-      name: 'test-skill',
-      description: 'Test',
-      execute: async () => ({ handled: false, confidence: 0 }),
-    });
-    // No throw = success
-  });
-
-  it('should throw registering skill before init', () => {
-    const runtime = new AgentRuntime();
-    expect(() =>
-      runtime.registerSkill({
-        name: 'test',
-        description: 'Test',
-        execute: async () => ({ handled: false, confidence: 0 }),
-      })
-    ).toThrow('Agent not initialized');
-  });
-});

package/tests/sandbox-manager.test.ts

@@ -1,46 +0,0 @@
-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/sandbox.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Sandbox } from '../src/core/sandbox';
-
-describe('Security Sandbox', () => {
-  it('should create sandbox with trust level', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.trustLevel).toBe('sandbox');
-  });
-
-  it('should restrict shell in sandbox mode', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.checkShellAccess()).toBe(false);
-  });
-
-  it('should allow shell in certified mode', () => {
-    const sb = new Sandbox({ trustLevel: 'certified', agentDir: '/tmp/agent' });
-    expect(sb.checkShellAccess()).toBe(true);
-  });
-
-  it('should restrict network in sandbox mode', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.checkNetworkAccess('https://api.openai.com')).toBe(false);
-  });
-
-  it('should allow network with allowlist', () => {
-    const sb = new Sandbox({
-      trustLevel: 'sandbox',
-      agentDir: '/tmp/agent',
-      networkAllowlist: ['api.openai.com'],
-    });
-    expect(sb.checkNetworkAccess('https://api.openai.com/v1/chat')).toBe(true);
-    expect(sb.checkNetworkAccess('https://evil.com')).toBe(false);
-  });
-
-  it('should allow wildcard network in listed mode', () => {
-    const sb = new Sandbox({ trustLevel: 'listed', agentDir: '/tmp/agent' });
-    expect(sb.checkNetworkAccess('https://anything.com')).toBe(true);
-  });
-
-  it('should return restrictions snapshot', () => {
-    const sb = new Sandbox({ trustLevel: 'verified', agentDir: '/tmp/agent' });
-    const r = sb.getRestrictions();
-    expect(r.shell).toBe(false);
-    expect(r.network.allowed.length).toBeGreaterThan(0);
-  });
-});