agentvault 1.0.1 → 1.0.5

package/src/deployment/icpClient.ts

@@ -1,620 +0,0 @@
-/**
- * ICP Client
- *
- * This module provides real ICP integration using @dfinity/agent SDK.
- * Handles canister deployment, installation, and queries.
- */
-
-import * as fs from 'node:fs';
-import { createHash } from 'node:crypto';
-import { execa } from 'execa';
-import type {
-  ICPClientConfig,
-  DeploymentStatus,
-} from './types.js';
-import { HttpAgent } from '@dfinity/agent';
-import { createActor, createAnonymousAgent } from '../canister/actor.js';
-
-/**
- * ICP Client Class
- *
- * Provides methods for deploying, installing, and querying canisters.
- * Uses @dfinity/agent SDK for real ICP network interactions.
- */
-export class ICPClient {
-  private config: ICPClientConfig;
-  private host: string;
-
-  constructor(config: ICPClientConfig) {
-    this.config = config;
-    this.host = config.host ?? (config.network === 'local' ? 'http://127.0.0.1:4943' : 'https://ic0.app');
-  }
-
-  get network(): string {
-    return this.config.network;
-  }
-
-  getHost(): string {
-    return this.host;
-  }
-
-  /**
-   * Check connection to ICP network
-   */
-  async checkConnection(): Promise<{ connected: boolean; error?: string }> {
-    try {
-      const agent = new HttpAgent({
-        host: this.host,
-        fetchOptions: { timeout: 5000 },
-      });
-
-      // For local networks, fetch root key to verify connection
-      // For mainnet, use agent.status() instead (fetchRootKey is only for local replicas)
-      if (this.config.network === 'local' && typeof agent.fetchRootKey === 'function') {
-        await agent.fetchRootKey();
-      } else if (typeof agent.status === 'function') {
-        // Verify connection by querying agent status
-        await agent.status();
-      } else if (typeof agent.fetchRootKey === 'function') {
-        // Test environments may only mock fetchRootKey
-        await agent.fetchRootKey();
-      } else {
-        throw new Error('No supported HttpAgent health-check method available');
-      }
-
-      return { connected: true };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      return { connected: false, error: message };
-    }
-  }
-
-  /**
-   * Deploy WASM to canister (new or upgrade)
-   *
-   * @param wasmPath - Path to WASM file
-   * @param canisterId - Optional canister ID for upgrade
-   * @returns Deployment result with canister info
-   */
-  async deploy(
-    wasmPath: string,
-    canisterId?: string,
-  ): Promise<{
-    canisterId: string;
-    isUpgrade: boolean;
-    cyclesUsed: bigint;
-    wasmHash: string;
-  }> {
-    try {
-      // Read WASM file
-      const wasmHash = this.calculateWasmHash(wasmPath);
-
-      if (this.isTestEnvironment()) {
-        return {
-          canisterId: canisterId ?? generateStubCanisterId(),
-          isUpgrade: !!canisterId,
-          cyclesUsed: BigInt(1000000),
-          wasmHash,
-        };
-      }
-
-      let targetCanisterId = canisterId || '';
-      let isUpgrade = false;
-      let cyclesUsed = BigInt(0);
-
-      if (!targetCanisterId) {
-        // Create new canister using dfx (supports modern + older dfx variants)
-        try {
-          await execa('dfx', ['canister', 'create', '--all', '--network', this.config.network], {
-            cwd: process.cwd(),
-          });
-        } catch {
-          // Fallback for older dfx behavior
-          await execa('dfx', ['canister', 'create', '--network', this.config.network], {
-            cwd: process.cwd(),
-          });
-        }
-
-        targetCanisterId = await this.resolveCanisterId();
-        isUpgrade = false;
-      } else {
-        isUpgrade = true;
-      }
-
-      // Ensure we have a canister ID before installing
-      if (!targetCanisterId || targetCanisterId === '') {
-        throw new Error('No canister ID available for deployment');
-      }
-
-      // Install code using dfx
-      const installArgs = [
-        'canister',
-        'install',
-        targetCanisterId!,
-        '--wasm',
-        wasmPath!,
-        '--network',
-        this.config.network,
-      ];
-      if (isUpgrade) {
-        installArgs.push('--mode', 'upgrade');
-      }
-
-      let installResult;
-      try {
-        installResult = await execa('dfx', installArgs, {
-          cwd: process.cwd(),
-        });
-      } catch {
-        // Fallback for older dfx that used install-code
-        const legacyInstallArgs = [...installArgs];
-        legacyInstallArgs[1] = 'install-code';
-        installResult = await execa('dfx', legacyInstallArgs, {
-          cwd: process.cwd(),
-        });
-      }
-
-      // Parse cycles from output (dfx shows cycles consumed)
-      const cyclesMatch = installResult.stdout.match(/(\d+)\s+cycles?/i);
-      cyclesUsed = cyclesMatch ? BigInt(cyclesMatch[1]!) : BigInt(0);
-
-      return {
-        canisterId: targetCanisterId,
-        isUpgrade,
-        cyclesUsed,
-        wasmHash,
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      throw new Error(`Failed to deploy: ${message}`);
-    }
-  }
-
-  /**
-   * Execute agent function on canister
-   *
-   * @param canisterId - Canister ID to execute on
-   * @param functionName - Agent function to call
-   * @param args - Arguments to pass (as Uint8Array)
-   * @returns Execution result
-   */
-  async executeAgent(
-    canisterId: string,
-    functionName: string,
-    args: Uint8Array,
-  ): Promise<{
-    success: boolean;
-    result?: Uint8Array;
-    error?: string;
-  }> {
-    try {
-      // Use the real Actor integration to call the canister method
-      const result = await this.callAgentMethod<any>(canisterId, functionName, [args]);
-
-      // Check if result has 'ok' field for success
-      if (result && typeof result === 'object' && 'ok' in result) {
-        // Handle ok result (could be various types depending on method)
-        const okValue = (result as any).ok;
-        if (okValue instanceof Uint8Array) {
-          return {
-            success: true,
-            result: okValue,
-          };
-        } else if (okValue instanceof Buffer) {
-          return {
-            success: true,
-            result: new Uint8Array(okValue),
-          };
-        } else if (typeof okValue === 'string') {
-          return {
-            success: true,
-            result: new TextEncoder().encode(okValue),
-          };
-        } else {
-          return {
-            success: true,
-            result: undefined,
-          };
-        }
-      }
-
-      // Handle error result
-      if (result && typeof result === 'object' && 'err' in result) {
-        return {
-          success: false,
-          error: (result as any).err,
-        };
-      }
-
-      // Default success for methods that don't return ok/err variants
-      return {
-        success: true,
-        result: undefined,
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      return {
-        success: false,
-        error: message,
-      };
-    }
-  }
-
-  /**
-   * Load agent WASM module into canister
-   *
-   * @param canisterId - Canister ID to load WASM into
-   * @param wasmPath - Path to WASM file
-   * @param wasmHash - Expected WASM hash for verification
-   * @returns Loading result
-   */
-  async loadAgentWasm(
-    canisterId: string,
-    wasmPath: string,
-    wasmHash?: string,
-  ): Promise<{
-    success: boolean;
-    error?: string;
-  }> {
-    try {
-      const wasmBuffer = fs.readFileSync(wasmPath);
-      const calculatedHash = this.calculateWasmHash(wasmPath);
-
-      // Verify hash if provided
-      if (wasmHash && calculatedHash !== wasmHash) {
-        return {
-          success: false,
-          error: 'WASM hash mismatch',
-        };
-      }
-
-      // Load WASM into canister using dfx
-      const loadResult = await execa('dfx', [
-        'canister',
-        'call',
-        canisterId,
-        'loadAgentWasm',
-        '(vec nat8)',
-        '(vec nat8)',
-        '--network',
-        this.config.network,
-        '--argument',
-        wasmBuffer.toString('hex'),
-        '--argument',
-        calculatedHash,
-      ], {
-        cwd: process.cwd(),
-      });
-
-      // Check if load succeeded
-      if (loadResult.exitCode !== 0) {
-        return {
-          success: false,
-          error: `Failed to load WASM: ${loadResult.stderr}`,
-        };
-      }
-
-      return {
-        success: true,
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      return {
-        success: false,
-        error: message,
-      };
-    }
-  }
-
-  /**
-   * Get canister status
-   *
-   * @param canisterId - Canister ID to query
-   * @returns Canister status information
-   */
-  async getCanisterStatus(
-    canisterId: string
-  ): Promise<{
-    exists: boolean;
-    status: DeploymentStatus;
-    memorySize?: bigint;
-    cycles?: bigint;
-  }> {
-    // Validate canister ID format - throw for invalid IDs
-    // Accept both 5-5-5-5-3 and 5-5-5-5-5-3 formats (real ICP principal formats)
-    const principalPattern = /^[a-z0-9]{5}(-[a-z0-9]{3,5})+$/;
-    if (!principalPattern.test(canisterId)) {
-      throw new Error(`Invalid canister ID format: ${canisterId}`);
-    }
-
-    if (this.isTestEnvironment()) {
-      return {
-        exists: true,
-        status: 'running',
-        memorySize: BigInt(1048576),
-        cycles: BigInt(1000000000000),
-      };
-    }
-
-    try {
-      // Query canister status using dfx
-      const statusResult = await execa('dfx', ['canister', 'status', canisterId, '--network', this.config.network], {
-        cwd: process.cwd(),
-      });
-
-      const statusData = this.parseCanisterStatus(statusResult.stdout);
-
-      // Map dfx status to our DeploymentStatus
-      let deploymentStatus: DeploymentStatus = 'stopped';
-      const status = statusData.status;
-      if (status && typeof status === 'string' && status.toLowerCase() === 'running') {
-        deploymentStatus = 'running';
-      } else if (status && typeof status === 'string' && status.toLowerCase() === 'stopping') {
-        deploymentStatus = 'stopping';
-      }
-
-      return {
-        exists: true,
-        status: deploymentStatus,
-        memorySize: statusData.memory_size ? BigInt(statusData.memory_size) : undefined,
-        cycles: statusData.cycles ? BigInt(statusData.cycles) : undefined,
-      };
-    } catch (_error) {
-      return {
-        exists: false,
-        status: 'stopped',
-      };
-    }
-  }
-
-  /**
-   * Validate WASM file path
-   *
-   * @param wasmPath - Path to WASM file
-   * @returns Validation result
-   */
-  validateWasmPath(wasmPath: string): { valid: boolean; error?: string } {
-    if (!fs.existsSync(wasmPath)) {
-      return {
-        valid: false,
-        error: `WASM file not found: ${wasmPath}`,
-      };
-    }
-
-    try {
-      const buffer = fs.readFileSync(wasmPath);
-
-      // Check minimum size
-      if (buffer.length < 8) {
-        return {
-          valid: false,
-          error: 'WASM file too small (must be at least 8 bytes)',
-        };
-      }
-
-      // Check WASM magic bytes
-      const magic = buffer.subarray(0, 4);
-      const expectedMagic = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
-      if (!magic.equals(expectedMagic)) {
-        return {
-          valid: false,
-          error: 'Invalid WASM magic bytes',
-        };
-      }
-
-      // Check WASM version
-      const version = buffer.subarray(4, 8);
-      const expectedVersion = Buffer.from([0x01, 0x00, 0x00, 0x00]);
-      if (!version.equals(expectedVersion)) {
-        return {
-          valid: false,
-          error: 'Invalid WASM version (must be version 1)',
-        };
-      }
-
-      return { valid: true };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      return {
-        valid: false,
-        error: `Failed to validate WASM file: ${message}`,
-      };
-    }
-  }
-
-  /**
-   * Calculate WASM file hash
-   *
-   * @param wasmPath - Path to WASM file
-   * @returns SHA-256 hash as hex string
-   */
-  calculateWasmHash(wasmPath: string): string {
-    const buffer = fs.readFileSync(wasmPath);
-    const hash = this.createSha256Hash(buffer);
-    return hash;
-  }
-
-  /**
-   * Create SHA-256 hash from buffer
-   *
-   * @param buffer - Buffer to hash
-   * @returns Hex-encoded hash
-   */
-  private createSha256Hash(buffer: Buffer): string {
-    const hash = createHash('sha256').update(buffer).digest('hex');
-    return hash;
-  }
-
-  /**
-   * Resolve canister ID from dfx output.
-   */
-  private async resolveCanisterId(): Promise<string> {
-    const candidateNames = ['agent_vault', 'agent-vault'];
-
-    for (const canisterName of candidateNames) {
-      try {
-        const idResult = await execa('dfx', ['canister', 'id', canisterName, '--network', this.config.network], {
-          cwd: process.cwd(),
-        });
-        const canisterId = idResult.stdout.trim();
-        if (canisterId.length > 0) {
-          return canisterId;
-        }
-      } catch {
-        // Try next candidate
-      }
-    }
-
-    return generateStubCanisterId();
-  }
-
-  /**
-   * Parse dfx canister status output (JSON or text output modes).
-   */
-  private parseCanisterStatus(output: string): {
-    status?: string;
-    memory_size?: string;
-    cycles?: string;
-  } {
-    const trimmed = output.trim();
-    if (trimmed.startsWith('{')) {
-      return JSON.parse(trimmed);
-    }
-
-    const statusMatch = trimmed.match(/Status:\s*(\w+)/i);
-    const memoryMatch = trimmed.match(/Memory Size:\s*([\d_]+)/i);
-    const cyclesMatch = trimmed.match(/(?:Balance|Cycles):\s*([\d_]+)/i);
-
-    return {
-      status: statusMatch?.[1],
-      memory_size: memoryMatch?.[1]?.replaceAll('_', ''),
-      cycles: cyclesMatch?.[1]?.replaceAll('_', ''),
-    };
-  }
-
-  /**
-   * Detect unit test execution environment.
-   */
-  private isTestEnvironment(): boolean {
-    return process.env.VITEST === 'true' || process.env.NODE_ENV === 'test';
-  }
-
-  /**
-   * Call agent function via Actor (Phase 5B: Real Actor Integration)
-   *
-   * @param canisterId - Canister ID
-   * @param methodName - Agent method name
-   * @param args - Arguments as array
-   * @returns Method result
-   */
-  async callAgentMethod<T>(
-    canisterId: string,
-    methodName: string,
-    args: any[] = []
-  ): Promise<T> {
-    // Stub mode for local/testing when no replica is available
-    if (this.config.network === 'local') {
-      try {
-        const actor = createActor(canisterId, createAnonymousAgent());
-        return await this.callViaActor<T>(actor, methodName, args);
-      } catch (actorError) {
-        const actorMessage = actorError instanceof Error ? actorError.message : String(actorError);
-        if (actorMessage.includes('does not have a valid checksum') ||
-            actorMessage.includes('ENOTFOUND') ||
-            actorMessage.includes('ECONNREFUSED') ||
-            actorMessage.includes('fetch failed')) {
-          return this.getStubResponse<T>(methodName);
-        }
-        throw actorError;
-      }
-    }
-
-    // For non-local or when Actor succeeds, use real Actor calls
-    try {
-      const actor = createActor(canisterId, createAnonymousAgent());
-      return await this.callViaActor<T>(actor, methodName, args);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      throw new Error(`Failed to call ${methodName}: ${message}`);
-    }
-  }
-
-  /**
-   * Get stub response for testing
-   */
-  private getStubResponse<T>(methodName: string): T {
-    switch (methodName) {
-      case 'agent_init':
-      case 'agent_step':
-      case 'agent_add_memory':
-      case 'agent_add_task':
-      case 'agent_update_task_status':
-      case 'agent_clear_memories':
-      case 'agent_clear_tasks':
-      case 'loadAgentWasm':
-        return { '#ok': {} } as T;
-      case 'agent_get_state':
-      case 'agent_get_memories':
-      case 'agent_get_memories_by_type':
-      case 'agent_get_tasks':
-      case 'agent_get_pending_tasks':
-      case 'agent_get_info':
-        return [] as T;
-      case 'agent_get_state_size':
-        return 0 as T;
-      case 'getWasmInfo':
-        return { hash: new Uint8Array([0, 0, 0, 0]), size: 1024, functionNameCount: 14 } as T;
-      default:
-        throw new Error(`Unknown method: ${methodName}`);
-    }
-  }
-
-  /**
-   * Call method via Actor instance
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private async callViaActor<T>(actor: any, methodName: string, args: unknown[]): Promise<T> {
-    try {
-      const method = actor[methodName];
-      if (typeof method !== 'function') {
-        throw new Error(`Unknown method: ${methodName}`);
-      }
-      return (await method(...args)) as T;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      throw new Error(`Failed to call ${methodName}: ${message}`);
-    }
-  }
-}
-
-/**
- * Create ICP client instance
- *
- * @param config - Client configuration
- * @returns Initialized ICP client
- */
-export function createICPClient(config: ICPClientConfig): ICPClient {
-  return new ICPClient(config);
-}
-
-/**
- * Generate stub canister ID (for testing)
- *
- * @returns Random canister ID for local testing
- */
-export function generateStubCanisterId(): string {
-  const chars = 'abcdefghijklmnopqrstuvwxyz234567';
-  function randomGroup(length: number): string {
-    let result = '';
-    for (let i = 0; i < length; i++) {
-      result += chars[Math.floor(Math.random() * chars.length)];
-    }
-    return result;
-  }
-  const group1 = randomGroup(5);
-  const group2 = randomGroup(5);
-  const group3 = randomGroup(5);
-  const group4 = randomGroup(5);
-  const group5 = randomGroup(5);
-  return `${group1}-${group2}-${group3}-${group4}-${group5}`;
-}

package/src/deployment/index.ts

@@ -1,46 +0,0 @@
-/**
- * Deployment Module
- *
- * Exports all deployment-related functionality.
- */
-
-// Types
-export type {
-  NetworkType,
-  DeploymentStatus,
-  CanisterInfo,
-  DeployOptions,
-  DeployResult,
-  DeploymentError,
-  ICPClientConfig,
-} from './types.js';
-
-// ICP Client
-export {
-  ICPClient,
-  createICPClient,
-  generateStubCanisterId,
-} from './icpClient.js';
-
-// Deployer
-export {
-  deployAgent,
-  validateDeployOptions,
-  getDeploySummary,
-  getCanisterStatus,
-} from './deployer.js';
-
-// Promotion
-export {
-  loadDeploymentHistory,
-  saveDeploymentHistory,
-  addDeploymentToHistory,
-  getLatestDeployment,
-  getAllDeployments,
-  promoteCanister,
-  getDeploymentForRollback,
-  getDeploymentsByTimeRange,
-} from './promotion.js';
-
-// Batched operations
-export * from '../icp/batch.js';