agentvault 1.0.1 → 1.0.5

package/src/testing/local-runner.ts

@@ -1,264 +0,0 @@
-/**
- * Local test runner for canister testing
- *
- * Provides test execution for unit, integration, and load tests against local canisters
- */
-
-import { execa } from 'execa';
-import path from 'node:path';
-import os from 'node:os';
-import fs from 'node:fs';
-import type {
-  TestRunnerOptions,
-  TestSuite,
-  LoadTestConfig,
-  LoadTestResult,
-} from './types.js';
-
-const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
-const TEST_RESULTS_DIR = path.join(AGENTVAULT_DIR, 'test-results');
-
-/**
- * Ensure test results directory exists
- */
-function ensureTestResultsDir(): void {
-  if (!fs.existsSync(AGENTVAULT_DIR)) {
-    fs.mkdirSync(AGENTVAULT_DIR, { recursive: true });
-  }
-  if (!fs.existsSync(TEST_RESULTS_DIR)) {
-    fs.mkdirSync(TEST_RESULTS_DIR, { recursive: true });
-  }
-}
-
-/**
- * Get test results file path
- */
-function getTestResultsPath(agentName: string, testType: string): string {
-  ensureTestResultsDir();
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  return path.join(TEST_RESULTS_DIR, `${agentName}-${testType}-${timestamp}.json`);
-}
-
-/**
- * Parse vitest output to extract test results
- */
-function parseVitestOutput(stdout: string): TestSuite {
-  const lines = stdout.split('\n');
-  const tests: TestSuite['tests'] = [];
-  let total = 0;
-  let passed = 0;
-  let failed = 0;
-  let skipped = 0;
-  let duration = 0;
-
-  for (const line of lines) {
-    const match = line.match(/^(PASS|FAIL|SKIP)\s+(.+) \((\d+)ms\)$/);
-    if (match) {
-      const [, status, nameRaw, timeRaw] = match;
-      const name = nameRaw?.trim() || 'unknown';
-      const time = timeRaw || '0';
-      tests.push({
-        name,
-        status: status === 'PASS' ? 'passed' : status === 'FAIL' ? 'failed' : 'skipped',
-        duration: parseInt(time, 10),
-      });
-      total++;
-      if (status === 'PASS') passed++;
-      else if (status === 'FAIL') failed++;
-      else skipped++;
-    }
-
-    const durationMatch = line.match(/Test Files\s+(\d+)\s+passed\s+\((\d+)\)/);
-    if (durationMatch && durationMatch[2]) {
-      duration = parseInt(durationMatch[2], 10);
-    }
-  }
-
-  return {
-    name: 'canister-tests',
-    total,
-    passed,
-    failed,
-    skipped,
-    duration,
-    tests,
-  };
-}
-
-/**
- * Run unit tests
- */
-export async function runUnitTests(options: TestRunnerOptions): Promise<TestSuite> {
-  const vitestArgs = [
-    'run',
-    '--reporter=verbose',
-  ];
-
-  if (options.network) {
-    vitestArgs.push(`--env.network=${options.network}`);
-  }
-
-  if (options.outputFormat === 'json') {
-    vitestArgs.push('--reporter=json');
-  }
-
-  vitestArgs.push('tests/unit');
-
-  const result = await execa('npx', ['vitest', ...vitestArgs], {
-    reject: false,
-    timeout: 120_000,
-  });
-
-  const testSuite = parseVitestOutput(result.stdout);
-
-  if (options.outputFormat === 'json') {
-    const resultsPath = getTestResultsPath(options.agentName, 'unit');
-    fs.writeFileSync(resultsPath, JSON.stringify(testSuite, null, 2), 'utf8');
-    console.log(`Test results saved to ${resultsPath}`);
-  }
-
-  return testSuite;
-}
-
-/**
- * Run integration tests
- */
-export async function runIntegrationTests(options: TestRunnerOptions): Promise<TestSuite> {
-  const vitestArgs = [
-    'run',
-    '--reporter=verbose',
-  ];
-
-  if (options.network) {
-    vitestArgs.push(`--env.network=${options.network}`);
-  }
-
-  if (options.outputFormat === 'json') {
-    vitestArgs.push('--reporter=json');
-  }
-
-  vitestArgs.push('tests/integration');
-
-  const result = await execa('npx', ['vitest', ...vitestArgs], {
-    reject: false,
-    timeout: 300_000,
-  });
-
-  const testSuite = parseVitestOutput(result.stdout);
-
-  if (options.outputFormat === 'json') {
-    const resultsPath = getTestResultsPath(options.agentName, 'integration');
-    fs.writeFileSync(resultsPath, JSON.stringify(testSuite, null, 2), 'utf8');
-    console.log(`Test results saved to ${resultsPath}`);
-  }
-
-  return testSuite;
-}
-
-/**
- * Run load tests
- */
-export async function runLoadTests(config: LoadTestConfig): Promise<LoadTestResult> {
-  const errors: Record<string, number> = {};
-  let totalRequests = 0;
-  let successfulRequests = 0;
-  let failedRequests = 0;
-  const responseTimes: number[] = [];
-  const startTime = Date.now();
-  const endTime = startTime + (config.duration * 1000);
-  const interval = config.duration * 1000 / (config.concurrency * 10);
-
-  const requestPromises: Array<Promise<{ success: boolean; responseTime: number; error?: string }>> = [];
-
-  for (let i = 0; i < config.concurrency * 10; i++) {
-    if (Date.now() >= endTime) break;
-
-    const startTimeMs = Date.now();
-
-    const request = execa('npx', ['icp', 'canister', 'call', config.canisterId, config.method, ...(config.args ? [config.args] : [])], {
-      reject: false,
-      timeout: 30_000,
-    });
-
-    const requestPromise = request.then((result) => {
-      const responseTime = Date.now() - startTimeMs;
-      if (result.exitCode === 0) {
-        return { success: true, responseTime };
-      } else {
-        const error = result.stderr || 'Unknown error';
-        errors[error] = (errors[error] || 0) + 1;
-        return { success: false, responseTime, error };
-      }
-    });
-
-    requestPromises.push(requestPromise);
-
-    await new Promise((resolve) => setTimeout(resolve, interval));
-  }
-
-  const results = await Promise.all(requestPromises);
-
-  for (const result of results) {
-    totalRequests++;
-    if (result.success) {
-      successfulRequests++;
-      responseTimes.push(result.responseTime);
-    } else {
-      failedRequests++;
-      if (result.error) {
-        errors[result.error] = (errors[result.error] || 0) + 1;
-      }
-    }
-  }
-
-  const actualDuration = (Date.now() - startTime) / 1000;
-  const requestsPerSecond = totalRequests / actualDuration;
-
-  const sortedTimes = responseTimes.sort((a, b) => a - b);
-  const minResponseTime = sortedTimes[0] || 0;
-  const maxResponseTime = sortedTimes[sortedTimes.length - 1] || 0;
-  const avgResponseTime = responseTimes.length > 0 
-    ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length 
-    : 0;
-
-  const percentiles = {
-    p50: sortedTimes[Math.floor(sortedTimes.length * 0.5)] || 0,
-    p90: sortedTimes[Math.floor(sortedTimes.length * 0.9)] || 0,
-    p95: sortedTimes[Math.floor(sortedTimes.length * 0.95)] || 0,
-    p99: sortedTimes[Math.floor(sortedTimes.length * 0.99)] || 0,
-  };
-
-  return {
-    totalRequests,
-    successfulRequests,
-    failedRequests,
-    requestsPerSecond,
-    avgResponseTime,
-    minResponseTime,
-    maxResponseTime,
-    percentiles,
-    errors,
-  };
-}
-
-/**
- * Run tests based on options
- */
-export async function runTests(options: TestRunnerOptions): Promise<TestSuite | LoadTestResult> {
-  switch (options.testType) {
-    case 'unit':
-      return runUnitTests(options);
-    case 'integration':
-      return runIntegrationTests(options);
-    case 'load-test':
-      if (!options.concurrency) {
-        throw new Error('Concurrency is required for load tests');
-      }
-      if (!options.loadDuration) {
-        throw new Error('Load duration is required for load tests');
-      }
-      throw new Error('Load test requires specific LoadTestConfig');
-    default:
-      throw new Error(`Unknown test type: ${options.testType}`);
-  }
-}

package/src/testing/types.ts

@@ -1,104 +0,0 @@
-/**
- * Types for local test runner
- */
-
-/** Test type */
-export type TestType = 'unit' | 'integration' | 'load-test';
-
-/** Test result status */
-export type TestStatus = 'passed' | 'failed' | 'skipped';
-
-/** Individual test case result */
-export interface TestCase {
-  /** Test name */
-  name: string;
-  /** Test status */
-  status: TestStatus;
-  /** Duration in milliseconds */
-  duration: number;
-  /** Error message if failed */
-  error?: string;
-  /** Error stack if failed */
-  stack?: string;
-}
-
-/** Test suite result */
-export interface TestSuite {
-  /** Suite name */
-  name: string;
-  /** Total number of tests */
-  total: number;
-  /** Number of passed tests */
-  passed: number;
-  /** Number of failed tests */
-  failed: number;
-  /** Number of skipped tests */
-  skipped: number;
-  /** Duration in milliseconds */
-  duration: number;
-  /** Individual test cases */
-  tests: TestCase[];
-}
-
-/** Test runner options */
-export interface TestRunnerOptions {
-  /** Agent name to test */
-  agentName: string;
-  /** Network to run tests against */
-  network: string;
-  /** Test type */
-  testType: TestType;
-  /** Enable watch mode */
-  watch?: boolean;
-  /** Load test concurrency */
-  concurrency?: number;
-  /** Load test duration in seconds */
-  loadDuration?: number;
-  /** Output format */
-  outputFormat?: 'json' | 'junit' | 'html';
-  /** Verbose output */
-  verbose?: boolean;
-}
-
-/** Load test configuration */
-export interface LoadTestConfig {
-  /** Number of concurrent requests */
-  concurrency: number;
-  /** Test duration in seconds */
-  duration: number;
-  /** Target canister ID */
-  canisterId: string;
-  /** Method to call */
-  method: string;
-  /** Request arguments (Candid format) */
-  args?: string;
-  /** Ramp-up time in seconds */
-  rampUp?: number;
-}
-
-/** Load test result */
-export interface LoadTestResult {
-  /** Total requests sent */
-  totalRequests: number;
-  /** Successful requests */
-  successfulRequests: number;
-  /** Failed requests */
-  failedRequests: number;
-  /** Requests per second */
-  requestsPerSecond: number;
-  /** Average response time in milliseconds */
-  avgResponseTime: number;
-  /** Minimum response time in milliseconds */
-  minResponseTime: number;
-  /** Maximum response time in milliseconds */
-  maxResponseTime: number;
-  /** Percentiles */
-  percentiles: {
-    p50: number;
-    p90: number;
-    p95: number;
-    p99: number;
-  };
-  /** Error breakdown */
-  errors: Record<string, number>;
-}

package/src/wallet/cbor-serializer.ts

@@ -1,323 +0,0 @@
-/**
- * CBOR Serializer/Deserializer
- *
- * Uses cbor-x to encode/decode wallet data and transactions.
- * Provides efficient binary serialization for wallet operations.
- */
-
-import * as cbor from 'cbor-x';
-import type {
-  WalletData,
-  Transaction,
-  TransactionRequest,
-  SignedTransaction,
-} from './types.js';
-
-/**
- * CBOR serializer options
- */
-interface CborOptions {
-  /** Include diagnostic info */
-  diagnostic?: boolean;
-  /** Use indefinite-length encoding */
-  indefinite?: boolean;
-}
-
-/**
- * Serialize wallet data to CBOR
- *
- * @param wallet - Wallet data to serialize
- * @param options - CBOR encoding options
- * @returns CBOR-encoded wallet data
- */
-export function serializeWallet(
-  wallet: WalletData,
-  _options: CborOptions = {}
-): Uint8Array {
-  try {
-    const walletObject = {
-      id: wallet.id,
-      agentId: wallet.agentId,
-      chain: wallet.chain,
-      address: wallet.address,
-      privateKey: wallet.privateKey,
-      mnemonic: wallet.mnemonic,
-      seedDerivationPath: wallet.seedDerivationPath,
-      createdAt: wallet.createdAt,
-      updatedAt: wallet.updatedAt,
-      creationMethod: wallet.creationMethod,
-      chainMetadata: wallet.chainMetadata,
-    };
-
-    const encoded = cbor.encode(walletObject);
-
-    // Add checksum for tamper detection
-    const checksum = calculateChecksum(encoded);
-    const withChecksum = new Uint8Array(encoded.length + checksum.length);
-    withChecksum.set(encoded);
-    withChecksum.set(checksum, encoded.length);
-
-    return withChecksum;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`Failed to serialize wallet: ${message}`);
-  }
-}
-
-/**
- * Deserialize CBOR data to wallet
- *
- * @param data - CBOR-encoded wallet data
- * @returns Deserialized wallet data
- */
-export function deserializeWallet(data: Uint8Array): WalletData {
-  try {
-    // Verify checksum
-    const checksumLength = 4;
-    if (data.length < checksumLength) {
-      throw new Error('Invalid wallet data: too short');
-    }
-
-    const payload = data.slice(0, -checksumLength);
-    const checksum = data.slice(-checksumLength);
-    const expectedChecksum = calculateChecksum(payload);
-
-    if (!buffersEqual(checksum, expectedChecksum)) {
-      throw new Error('Invalid wallet data: checksum mismatch');
-    }
-
-    const decoded = cbor.decode(payload) as any;
-
-    if (!decoded) {
-      throw new Error('Invalid wallet data: decode failed');
-    }
-
-    return {
-      id: decoded.id || '',
-      agentId: decoded.agentId || '',
-      chain: decoded.chain || 'cketh',
-      address: decoded.address || '',
-      privateKey: decoded.privateKey,
-      mnemonic: decoded.mnemonic,
-      seedDerivationPath: decoded.seedDerivationPath,
-      createdAt: decoded.createdAt || Date.now(),
-      updatedAt: decoded.updatedAt || Date.now(),
-      creationMethod: decoded.creationMethod || 'seed',
-      chainMetadata: decoded.chainMetadata,
-    } as WalletData;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`Failed to deserialize wallet: ${message}`);
-  }
-}
-
-/**
- * Serialize transaction to CBOR
- *
- * @param transaction - Transaction to serialize
- * @returns CBOR-encoded transaction
- */
-export function serializeTransaction(transaction: Transaction): Uint8Array {
-  try {
-    const txObject = {
-      hash: transaction.hash,
-      from: transaction.from,
-      to: transaction.to,
-      amount: transaction.amount,
-      chain: transaction.chain,
-      timestamp: transaction.timestamp,
-      status: transaction.status,
-      fee: transaction.fee,
-      data: transaction.data,
-    };
-
-    return cbor.encode(txObject);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`Failed to serialize transaction: ${message}`);
-  }
-}
-
-/**
- * Deserialize CBOR data to transaction
- *
- * @param data - CBOR-encoded transaction data
- * @returns Deserialized transaction
- */
-export function deserializeTransaction(data: Uint8Array): Transaction {
-  try {
-    const decoded = cbor.decode(data);
-
-    return {
-      hash: decoded.hash || '',
-      from: decoded.from || '',
-      to: decoded.to || '',
-      amount: decoded.amount || '0',
-      chain: decoded.chain || 'cketh',
-      timestamp: decoded.timestamp || Date.now(),
-      status: decoded.status || 'pending',
-      fee: decoded.fee,
-      data: decoded.data,
-    } as Transaction;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`Failed to deserialize transaction: ${message}`);
-  }
-}
-
-/**
- * Serialize transaction request to CBOR
- *
- * @param request - Transaction request to serialize
- * @returns CBOR-encoded transaction request
- */
-export function serializeTransactionRequest(request: TransactionRequest): Uint8Array {
-  try {
-    const requestObject = {
-      to: request.to,
-      amount: request.amount,
-      chain: request.chain,
-      memo: request.memo,
-      gasPrice: request.gasPrice,
-      gasLimit: request.gasLimit,
-    };
-
-    return cbor.encode(requestObject);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`Failed to serialize transaction request: ${message}`);
-  }
-}
-
-/**
- * Deserialize CBOR data to transaction request
- *
- * @param data - CBOR-encoded transaction request data
- * @returns Deserialized transaction request
- */
-export function deserializeTransactionRequest(data: Uint8Array): TransactionRequest {
-  try {
-    const decoded = cbor.decode(data);
-
-    return {
-      to: decoded.to || '',
-      amount: decoded.amount || '0',
-      chain: decoded.chain || 'cketh',
-      memo: decoded.memo,
-      gasPrice: decoded.gasPrice,
-      gasLimit: decoded.gasLimit,
-    } as TransactionRequest;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`Failed to deserialize transaction request: ${message}`);
-  }
-}
-
-/**
- * Serialize signed transaction to CBOR
- *
- * @param signedTx - Signed transaction to serialize
- * @returns CBOR-encoded signed transaction
- */
-export function serializeSignedTransaction(signedTx: SignedTransaction): Uint8Array {
-  try {
-    const txObject = {
-      txHash: signedTx.txHash,
-      signedTx: signedTx.signedTx,
-      signature: signedTx.signature,
-      request: signedTx.request,
-    };
-
-    return cbor.encode(txObject);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`Failed to serialize signed transaction: ${message}`);
-  }
-}
-
-/**
- * Deserialize CBOR data to signed transaction
- *
- * @param data - CBOR-encoded signed transaction data
- * @returns Deserialized signed transaction
- */
-export function deserializeSignedTransaction(data: Uint8Array): SignedTransaction {
-  try {
-    const decoded = cbor.decode(data);
-
-    return {
-      txHash: decoded.txHash || '',
-      signedTx: decoded.signedTx || '',
-      signature: decoded.signature,
-      request: decoded.request,
-    } as SignedTransaction;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Unknown error';
-    throw new Error(`Failed to deserialize signed transaction: ${message}`);
-  }
-}
-
-/**
- * Calculate checksum for data integrity
- *
- * @param data - Data to checksum
- * @returns 4-byte checksum
- */
-function calculateChecksum(data: Uint8Array): Uint8Array {
-  let checksum = 0;
-  for (let i = 0; i < data.length; i++) {
-    const byte = data[i];
-    if (byte !== undefined) {
-      checksum = ((checksum << 8) ^ byte) >>> 0;
-    }
-  }
-
-  const result = new Uint8Array(4);
-  const view = new DataView(result.buffer);
-  view.setUint32(0, checksum, false); // Big-endian
-
-  return result;
-}
-
-/**
- * Compare two buffers for equality
- *
- * @param a - First buffer
- * @param b - Second buffer
- * @returns True if buffers are equal
- */
-function buffersEqual(a: Uint8Array, b: Uint8Array): boolean {
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Validate CBOR data structure
- *
- * @param data - CBOR-encoded data
- * @returns True if data appears valid
- */
-export function validateCborData(data: Uint8Array): boolean {
-  try {
-    // Attempt to decode
-    const decoded = cbor.decode(data);
-
-    // Check if it's an object
-    if (!decoded || typeof decoded !== 'object' || decoded === null) {
-      return false;
-    }
-
-    return true;
-  } catch {
-    return false;
-  }
-}