agora-skill 1.0.0

package/test/credentials.test.ts

@@ -0,0 +1,155 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest'
+import { mkdirSync, rmSync, existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import {
+  generateApiKey,
+  maskApiKey,
+  getActiveApiKey,
+  getActiveEnvironment,
+  getApiEndpoint,
+  saveCredentials,
+  loadCredentials,
+  ensureAgoraDirs,
+  type AgentCredentials,
+} from '../src/auth/credentials.js'
+
+// --- Pure function tests (no filesystem) ---
+
+describe('generateApiKey', () => {
+  test('sandbox key has correct prefix', () => {
+    const key = generateApiKey('sandbox')
+    expect(key).toMatch(/^agora_sk_test_[0-9a-f]{48}$/)
+  })
+
+  test('production key has correct prefix', () => {
+    const key = generateApiKey('production')
+    expect(key).toMatch(/^agora_sk_live_[0-9a-f]{48}$/)
+  })
+
+  test('generates unique keys each time', () => {
+    const key1 = generateApiKey('sandbox')
+    const key2 = generateApiKey('sandbox')
+    expect(key1).not.toBe(key2)
+  })
+})
+
+describe('maskApiKey', () => {
+  test('masks long keys preserving prefix and last 4 chars', () => {
+    const key = 'agora_sk_test_aabbccdd11223344'
+    const masked = maskApiKey(key)
+    expect(masked).toContain('****')
+    expect(masked).not.toBe(key)
+    expect(masked.endsWith('3344')).toBe(true)
+  })
+
+  test('masks short keys gracefully', () => {
+    const masked = maskApiKey('short_key')
+    expect(masked).toContain('****')
+  })
+})
+
+describe('getActiveApiKey', () => {
+  const baseCreds: AgentCredentials = {
+    agent_id: 'agent_test',
+    agent_name: 'test',
+    api_key: 'agora_sk_test_sandbox',
+    api_key_live: null,
+    api_endpoint: 'https://api.agora.youlidao.ai',
+    wallet_address: '0x123',
+    environment: 'sandbox',
+    created_at: '2026-04-01T00:00:00Z',
+    key_rotated_at: null,
+  }
+
+  test('returns sandbox key when environment is sandbox', () => {
+    expect(getActiveApiKey(baseCreds)).toBe('agora_sk_test_sandbox')
+  })
+
+  test('returns sandbox key when production but no live key', () => {
+    const creds = { ...baseCreds, environment: 'production' as const }
+    expect(getActiveApiKey(creds)).toBe('agora_sk_test_sandbox')
+  })
+
+  test('returns live key when production with live key', () => {
+    const creds = {
+      ...baseCreds,
+      environment: 'production' as const,
+      api_key_live: 'agora_sk_live_production',
+    }
+    expect(getActiveApiKey(creds)).toBe('agora_sk_live_production')
+  })
+})
+
+describe('getActiveEnvironment', () => {
+  test('returns sandbox for sandbox creds', () => {
+    const creds = { environment: 'sandbox' } as AgentCredentials
+    expect(getActiveEnvironment(creds)).toBe('sandbox')
+  })
+
+  test('returns production for production creds', () => {
+    const creds = { environment: 'production' } as AgentCredentials
+    expect(getActiveEnvironment(creds)).toBe('production')
+  })
+})
+
+describe('getApiEndpoint', () => {
+  test('returns configured endpoint', () => {
+    const creds = { api_endpoint: 'https://custom.api.com' } as AgentCredentials
+    expect(getApiEndpoint(creds)).toBe('https://custom.api.com')
+  })
+
+  test('returns default endpoint when empty', () => {
+    const creds = { api_endpoint: '' } as AgentCredentials
+    expect(getApiEndpoint(creds)).toBe('https://api.agora.youlidao.ai')
+  })
+})
+
+// --- Filesystem tests (use tmp dir) ---
+
+describe('credentials filesystem', () => {
+  let tmpRoot: string
+
+  beforeEach(() => {
+    tmpRoot = join(tmpdir(), `agora-test-${Date.now()}`)
+    mkdirSync(tmpRoot, { recursive: true })
+  })
+
+  afterEach(() => {
+    rmSync(tmpRoot, { recursive: true, force: true })
+  })
+
+  test('saveCredentials + loadCredentials round-trip', () => {
+    const credDir = join(tmpRoot, 'credentials')
+    mkdirSync(credDir, { recursive: true })
+
+    const creds: AgentCredentials = {
+      agent_id: 'agent_abc123',
+      agent_name: 'test-agent',
+      api_key: 'agora_sk_test_roundtrip',
+      api_key_live: null,
+      api_endpoint: 'https://api.agora.youlidao.ai',
+      wallet_address: '0xdeadbeef',
+      environment: 'sandbox',
+      created_at: '2026-04-01T00:00:00Z',
+      key_rotated_at: null,
+    }
+
+    const credPath = join(credDir, 'default.json')
+    const { writeFileSync } = require('node:fs')
+    writeFileSync(credPath, JSON.stringify(creds, null, 2), { mode: 0o600 })
+
+    const loaded = JSON.parse(readFileSync(credPath, 'utf-8')) as AgentCredentials
+    expect(loaded.agent_id).toBe('agent_abc123')
+    expect(loaded.agent_name).toBe('test-agent')
+    expect(loaded.api_key).toBe('agora_sk_test_roundtrip')
+    expect(loaded.environment).toBe('sandbox')
+    expect(loaded.wallet_address).toBe('0xdeadbeef')
+  })
+
+  test('loadCredentials returns null for nonexistent agent', () => {
+    const result = loadCredentials('nonexistent-agent-xyz')
+    // Will return null because ~/.agora/credentials/nonexistent-agent-xyz.json doesn't exist
+    expect(result).toBeNull()
+  })
+})

package/test/installer.test.ts

@@ -0,0 +1,99 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest'
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+/**
+ * Test the injectMcpConfig logic in isolation (extracted behavior).
+ * We test the file-level behavior without calling the full install()
+ * since install() touches ~/.agora/ and real filesystem paths.
+ */
+
+function injectMcpConfig(mcpPath: string): void {
+  let config: Record<string, unknown> = {}
+
+  if (existsSync(mcpPath)) {
+    try {
+      config = JSON.parse(readFileSync(mcpPath, 'utf-8'))
+    } catch {
+      config = {}
+    }
+  }
+
+  const servers = (config['mcpServers'] as Record<string, unknown>) || {}
+  servers['agora'] = {
+    command: 'npx',
+    args: ['-y', 'agora-skill', 'serve'],
+  }
+  config['mcpServers'] = servers
+
+  writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n')
+}
+
+describe('MCP Config Injection', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `agora-installer-test-${Date.now()}`)
+    mkdirSync(tmpDir, { recursive: true })
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  test('creates .mcp.json when it does not exist', () => {
+    const mcpPath = join(tmpDir, '.mcp.json')
+    injectMcpConfig(mcpPath)
+
+    expect(existsSync(mcpPath)).toBe(true)
+    const config = JSON.parse(readFileSync(mcpPath, 'utf-8'))
+    expect(config.mcpServers.agora).toEqual({
+      command: 'npx',
+      args: ['-y', 'agora-skill', 'serve'],
+    })
+  })
+
+  test('preserves existing MCP servers when injecting', () => {
+    const mcpPath = join(tmpDir, '.mcp.json')
+    writeFileSync(mcpPath, JSON.stringify({
+      mcpServers: {
+        orchestrix: {
+          type: 'http',
+          url: 'https://orchestrix-mcp.youlidao.ai/api/mcp',
+        },
+      },
+    }))
+
+    injectMcpConfig(mcpPath)
+
+    const config = JSON.parse(readFileSync(mcpPath, 'utf-8'))
+    expect(config.mcpServers.orchestrix).toBeDefined()
+    expect(config.mcpServers.agora).toBeDefined()
+  })
+
+  test('overwrites existing agora config on re-install', () => {
+    const mcpPath = join(tmpDir, '.mcp.json')
+    writeFileSync(mcpPath, JSON.stringify({
+      mcpServers: {
+        agora: { command: 'old-command' },
+      },
+    }))
+
+    injectMcpConfig(mcpPath)
+
+    const config = JSON.parse(readFileSync(mcpPath, 'utf-8'))
+    expect(config.mcpServers.agora.command).toBe('npx')
+    expect(config.mcpServers.agora.args).toEqual(['-y', 'agora-skill', 'serve'])
+  })
+
+  test('handles corrupted .mcp.json gracefully', () => {
+    const mcpPath = join(tmpDir, '.mcp.json')
+    writeFileSync(mcpPath, '{ invalid json !!!!')
+
+    injectMcpConfig(mcpPath)
+
+    const config = JSON.parse(readFileSync(mcpPath, 'utf-8'))
+    expect(config.mcpServers.agora).toBeDefined()
+  })
+})

package/test/smoke.test.ts

@@ -0,0 +1,64 @@
+import { describe, test, expect } from 'vitest'
+import { execSync } from 'node:child_process'
+import { join } from 'node:path'
+import { existsSync } from 'node:fs'
+
+const CLI_PATH = join(__dirname, '..', 'dist', 'bin', 'agora-skill.js')
+
+describe('Smoke Tests', () => {
+  test('CLI binary exists after build', () => {
+    expect(existsSync(CLI_PATH)).toBe(true)
+  })
+
+  test('CLI --help exits 0 and shows usage', () => {
+    const output = execSync(`node ${CLI_PATH} --help`, { encoding: 'utf-8' })
+    expect(output).toContain('agora-skill')
+    expect(output).toContain('install')
+    expect(output).toContain('serve')
+  })
+
+  test('CLI --version exits 0', () => {
+    const output = execSync(`node ${CLI_PATH} --version`, { encoding: 'utf-8' })
+    expect(output.trim()).toBe('1.0.0')
+  })
+
+  test('CLI install --help shows endpoint option', () => {
+    const output = execSync(`node ${CLI_PATH} install --help`, { encoding: 'utf-8' })
+    expect(output).toContain('--endpoint')
+  })
+
+  test('CLI serve --help shows description', () => {
+    const output = execSync(`node ${CLI_PATH} serve --help`, { encoding: 'utf-8' })
+    expect(output).toContain('MCP server')
+  })
+
+  test('all tool schema modules are importable', async () => {
+    const { publishSchema } = await import('../src/tools/publish.js')
+    const { searchSchema } = await import('../src/tools/search.js')
+    const { bidSchema } = await import('../src/tools/bid.js')
+    const { deliverSchema } = await import('../src/tools/deliver.js')
+    const { statusSchema } = await import('../src/tools/status.js')
+
+    expect(publishSchema).toBeDefined()
+    expect(searchSchema).toBeDefined()
+    expect(bidSchema).toBeDefined()
+    expect(deliverSchema).toBeDefined()
+    expect(statusSchema).toBeDefined()
+  })
+
+  test('AgoraClient is constructable with mock creds', async () => {
+    const { AgoraClient } = await import('../src/client.js')
+    const client = new AgoraClient({
+      agent_id: 'agent_smoke',
+      agent_name: 'smoke',
+      api_key: 'agora_sk_test_smoke',
+      api_key_live: null,
+      api_endpoint: 'https://localhost:9999',
+      wallet_address: '0x0',
+      environment: 'sandbox',
+      created_at: '2026-01-01T00:00:00Z',
+      key_rotated_at: null,
+    })
+    expect(client).toBeDefined()
+  })
+})

package/test/tools.test.ts

@@ -0,0 +1,223 @@
+import { describe, test, expect } from 'vitest'
+import { publishSchema } from '../src/tools/publish.js'
+import { searchSchema } from '../src/tools/search.js'
+import { bidSchema } from '../src/tools/bid.js'
+import { deliverSchema } from '../src/tools/deliver.js'
+import { statusSchema } from '../src/tools/status.js'
+
+describe('Tool Schema Validation', () => {
+  describe('publishSchema', () => {
+    test('accepts valid publish params', () => {
+      const result = publishSchema.safeParse({
+        title: '8xA100 for 2h fine-tuning',
+        description: 'Need CUDA 12.x capable GPUs for model training job',
+        skill: 'compute',
+        budget: 200,
+        deadline: '2h',
+      })
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.executor_type).toBe('agent')
+      }
+    })
+
+    test('accepts full publish params', () => {
+      const result = publishSchema.safeParse({
+        title: 'GPU compute task for training',
+        description: 'Need CUDA 12.x capable GPUs for a large model training run',
+        skill: 'compute',
+        budget: 500,
+        deadline: '2h',
+        executor_type: 'human',
+        acceptance_criteria: 'Model achieves 95% accuracy on test set',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    test('rejects title shorter than 5 chars', () => {
+      const result = publishSchema.safeParse({
+        title: 'GPU',
+        description: 'A sufficiently long description for the task',
+        skill: 'compute',
+        budget: 200,
+        deadline: '2h',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    test('rejects description shorter than 20 chars', () => {
+      const result = publishSchema.safeParse({
+        title: 'Valid title here',
+        description: 'Too short',
+        skill: 'compute',
+        budget: 200,
+        deadline: '2h',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    test('rejects zero budget', () => {
+      const result = publishSchema.safeParse({
+        title: 'Valid title here',
+        description: 'A sufficiently long description text',
+        skill: 'compute',
+        budget: 0,
+        deadline: '2h',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    test('rejects negative budget', () => {
+      const result = publishSchema.safeParse({
+        title: 'Valid title here',
+        description: 'A sufficiently long description text',
+        skill: 'compute',
+        budget: -100,
+        deadline: '2h',
+      })
+      expect(result.success).toBe(false)
+    })
+
+    test('rejects invalid executor_type', () => {
+      const result = publishSchema.safeParse({
+        title: 'Valid title here',
+        description: 'A sufficiently long description text',
+        skill: 'compute',
+        budget: 100,
+        deadline: '2h',
+        executor_type: 'INVALID',
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('searchSchema', () => {
+    test('accepts empty params with defaults', () => {
+      const result = searchSchema.safeParse({})
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.limit).toBe(10)
+      }
+    })
+
+    test('accepts full search params', () => {
+      const result = searchSchema.safeParse({
+        skill: 'nlp-sentiment',
+        budget_min: 50,
+        budget_max: 500,
+        executor_type: 'agent',
+        keyword: 'GPU training',
+        limit: 20,
+      })
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('bidSchema', () => {
+    test('accepts valid bid params', () => {
+      const result = bidSchema.safeParse({
+        task_id: 'task_01HZ',
+        price: 180,
+        estimated_hours: 2,
+      })
+      expect(result.success).toBe(true)
+    })
+
+    test('accepts full bid params', () => {
+      const result = bidSchema.safeParse({
+        task_id: 'task_01HZ',
+        price: 180,
+        estimated_hours: 4,
+        message: 'I have idle A100 capacity right now',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    test('rejects missing task_id', () => {
+      const result = bidSchema.safeParse({
+        price: 180,
+        estimated_hours: 2,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    test('rejects zero price', () => {
+      const result = bidSchema.safeParse({
+        task_id: 'task_01HZ',
+        price: 0,
+        estimated_hours: 2,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    test('rejects estimated_hours below 1', () => {
+      const result = bidSchema.safeParse({
+        task_id: 'task_01HZ',
+        price: 100,
+        estimated_hours: 0,
+      })
+      expect(result.success).toBe(false)
+    })
+
+    test('rejects estimated_hours above 720', () => {
+      const result = bidSchema.safeParse({
+        task_id: 'task_01HZ',
+        price: 100,
+        estimated_hours: 1000,
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('deliverSchema', () => {
+    test('accepts text content delivery', () => {
+      const result = deliverSchema.safeParse({
+        task_id: 'task_01HZ',
+        content: 'Here is the analysis result with detailed findings...',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    test('accepts file reference delivery', () => {
+      const result = deliverSchema.safeParse({
+        task_id: 'task_01HZ',
+        file_references: ['s3://results/model.safetensors', 'https://wandb.ai/run/123'],
+        notes: 'Training completed with 95% accuracy',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    test('rejects more than 10 file references', () => {
+      const result = deliverSchema.safeParse({
+        task_id: 'task_01HZ',
+        file_references: Array.from({ length: 11 }, (_, i) => `https://file${i}.com`),
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('statusSchema', () => {
+    test('accepts empty params with defaults', () => {
+      const result = statusSchema.safeParse({})
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.role).toBe('all')
+      }
+    })
+
+    test('accepts specific task_id', () => {
+      const result = statusSchema.safeParse({
+        task_id: 'task_01HZ',
+        role: 'publisher',
+      })
+      expect(result.success).toBe(true)
+    })
+
+    test('rejects invalid role', () => {
+      const result = statusSchema.safeParse({
+        role: 'admin',
+      })
+      expect(result.success).toBe(false)
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}