agentvault 1.0.0 → 1.0.2

package/dist/src/deployment/deployer.js

@@ -0,0 +1,211 @@
+/**
+ * Agent Deployer
+ *
+ * Main orchestrator for the ICP canister deployment pipeline.
+ * Coordinates validation, client setup, and deployment operations.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createICPClient } from './icpClient.js';
+import { detectToolchain } from '../icp/tool-detector.js';
+import * as icpcli from '../icp/icpcli.js';
+import { getEnvironment } from '../icp/environment.js';
+/**
+ * Extract agent name from WASM file path
+ */
+function extractAgentName(wasmPath) {
+    const basename = path.basename(wasmPath);
+    // Remove .wasm extension
+    return basename.replace(/\.wasm$/, '');
+}
+/**
+ * Validate deployment options
+ */
+export function validateDeployOptions(options) {
+    const errors = [];
+    const warnings = [];
+    // Validate WASM path using client
+    const client = createICPClient({ network: options.network });
+    const wasmValidation = client.validateWasmPath(options.wasmPath);
+    if (!wasmValidation.valid) {
+        errors.push({
+            code: 'INVALID_WASM',
+            message: wasmValidation.error,
+        });
+    }
+    // Validate network - requires standard network name or an explicit environment config
+    const knownNetworks = ['local', 'ic', 'mainnet', 'dev', 'staging', 'production'];
+    if (!knownNetworks.includes(options.network)) {
+        errors.push({
+            code: 'INVALID_NETWORK',
+            message: `Network '${options.network}' is not a standard name. Ensure it is defined in your icp.yaml.`,
+        });
+    }
+    // Warn about mainnet deployment
+    if (options.network === 'ic' && !options.skipConfirmation) {
+        warnings.push('Deploying to IC mainnet will consume cycles. Ensure you have sufficient balance.');
+    }
+    // Warn about upgrade without canister ID check
+    if (options.canisterId) {
+        warnings.push(`Upgrading existing canister: ${options.canisterId}`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Get deployment preview/summary
+ *
+ * Useful for dry-run functionality
+ */
+export function getDeploySummary(options) {
+    const validation = validateDeployOptions(options);
+    // Calculate WASM hash if file exists
+    let wasmHash = '';
+    let wasmSize = 0;
+    if (validation.valid) {
+        try {
+            const client = createICPClient({ network: options.network });
+            wasmHash = client.calculateWasmHash(options.wasmPath);
+            wasmSize = fs.statSync(options.wasmPath).size;
+        }
+        catch {
+            // File doesn't exist or can't be read
+        }
+    }
+    return {
+        agentName: extractAgentName(options.wasmPath),
+        wasmPath: options.wasmPath,
+        wasmHash,
+        wasmSize,
+        network: options.network,
+        isUpgrade: !!options.canisterId,
+        canisterId: options.canisterId,
+        validation,
+    };
+}
+/**
+ * Deploy an agent to ICP
+ *
+ * This is the main entry point for the deployment pipeline.
+ * Uses auto-detection to choose between icp-cli and the @dfinity/agent SDK.
+ *
+ * Priority: icp-cli > @dfinity/agent SDK (with dfx fallback)
+ *
+ * @param options - Deployment options
+ * @returns Deployment result with canister info
+ */
+export async function deployAgent(options) {
+    // Validate options
+    const validation = validateDeployOptions(options);
+    if (!validation.valid) {
+        const errorMessages = validation.errors.map((e) => e.message).join('; ');
+        throw new Error(`Deployment validation failed: ${errorMessages}`);
+    }
+    // Detect available toolchain
+    const toolchain = await detectToolchain();
+    // Determine which tool to use
+    if (toolchain.icp.available && (options.environment || options.identity)) {
+        // Use icp-cli when explicitly requesting environments or identity features
+        return deployWithIcpCli(options, validation.warnings);
+    }
+    else if (toolchain.preferredDeployTool === 'icp') {
+        // Prefer icp-cli when available
+        return deployWithIcpCli(options, validation.warnings);
+    }
+    else {
+        // Fall back to @dfinity/agent SDK
+        return deployWithSdk(options, validation.warnings);
+    }
+}
+/**
+ * Deploy using icp-cli tool.
+ */
+async function deployWithIcpCli(options, warnings) {
+    // Resolve environment from options or network
+    const envName = options.environment ?? options.network;
+    const envConfig = getEnvironment(envName);
+    const identity = options.identity ?? envConfig.identity;
+    // Determine deploy mode
+    const mode = options.mode ?? (options.canisterId ? 'upgrade' : 'auto');
+    const result = await icpcli.deploy({
+        environment: envName,
+        identity,
+        mode,
+        projectRoot: options.projectRoot,
+    });
+    if (!result.success) {
+        throw new Error(`icp-cli deploy failed: ${result.stderr || result.stdout}`);
+    }
+    // Parse canister ID from output (best effort)
+    const canisterIdMatch = result.stdout.match(/([a-z0-9]{5}-[a-z0-9]{5}-[a-z0-9]{5}-[a-z0-9]{5}-[a-z0-9]{3})/);
+    const canisterId = canisterIdMatch?.[1] ?? options.canisterId ?? 'unknown';
+    const canisterInfo = {
+        canisterId,
+        network: options.network,
+        agentName: extractAgentName(options.wasmPath),
+        deployedAt: new Date(),
+    };
+    return {
+        canister: canisterInfo,
+        isUpgrade: mode === 'upgrade',
+        warnings: [...warnings, `Deployed via icp-cli (environment: ${envName})`],
+        deployTool: 'icp',
+    };
+}
+/**
+ * Deploy using @dfinity/agent SDK (original implementation).
+ */
+async function deployWithSdk(options, warnings) {
+    // Create ICP client
+    const client = createICPClient({
+        network: options.network,
+        identity: options.identityPath,
+    });
+    // Check network connection
+    const connectionCheck = await client.checkConnection();
+    if (!connectionCheck.connected) {
+        throw new Error(`Failed to connect to ${options.network} network: ${connectionCheck.error ?? 'Unknown error'}`);
+    }
+    // Deploy the WASM
+    const deployResult = await client.deploy(options.wasmPath, options.canisterId);
+    // Build canister info
+    const canisterInfo = {
+        canisterId: deployResult.canisterId,
+        network: options.network,
+        agentName: extractAgentName(options.wasmPath),
+        deployedAt: new Date(),
+        wasmHash: deployResult.wasmHash,
+    };
+    return {
+        canister: canisterInfo,
+        isUpgrade: deployResult.isUpgrade,
+        cyclesUsed: deployResult.cyclesUsed,
+        warnings,
+        deployTool: 'sdk',
+    };
+}
+/**
+ * Check if a canister exists and get its status
+ */
+export async function getCanisterStatus(canisterId, network) {
+    const client = createICPClient({ network });
+    try {
+        const status = await client.getCanisterStatus(canisterId);
+        if (!status.exists) {
+            return { exists: false };
+        }
+        return {
+            exists: status.exists,
+            status: status.status,
+            memorySize: status.memorySize,
+            cycles: status.cycles,
+        };
+    }
+    catch {
+        return { exists: false };
+    }
+}
+//# sourceMappingURL=deployer.js.map

package/dist/src/deployment/icpClient.d.ts

@@ -0,0 +1,144 @@
+/**
+ * ICP Client
+ *
+ * This module provides real ICP integration using @dfinity/agent SDK.
+ * Handles canister deployment, installation, and queries.
+ */
+import type { ICPClientConfig, DeploymentStatus } from './types.js';
+/**
+ * ICP Client Class
+ *
+ * Provides methods for deploying, installing, and querying canisters.
+ * Uses @dfinity/agent SDK for real ICP network interactions.
+ */
+export declare class ICPClient {
+    private config;
+    private host;
+    constructor(config: ICPClientConfig);
+    get network(): string;
+    getHost(): string;
+    /**
+     * Check connection to ICP network
+     */
+    checkConnection(): Promise<{
+        connected: boolean;
+        error?: string;
+    }>;
+    /**
+     * 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
+     */
+    deploy(wasmPath: string, canisterId?: string): Promise<{
+        canisterId: string;
+        isUpgrade: boolean;
+        cyclesUsed: bigint;
+        wasmHash: string;
+    }>;
+    /**
+     * 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
+     */
+    executeAgent(canisterId: string, functionName: string, args: Uint8Array): Promise<{
+        success: boolean;
+        result?: Uint8Array;
+        error?: string;
+    }>;
+    /**
+     * 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
+     */
+    loadAgentWasm(canisterId: string, wasmPath: string, wasmHash?: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get canister status
+     *
+     * @param canisterId - Canister ID to query
+     * @returns Canister status information
+     */
+    getCanisterStatus(canisterId: string): Promise<{
+        exists: boolean;
+        status: DeploymentStatus;
+        memorySize?: bigint;
+        cycles?: bigint;
+    }>;
+    /**
+     * Validate WASM file path
+     *
+     * @param wasmPath - Path to WASM file
+     * @returns Validation result
+     */
+    validateWasmPath(wasmPath: string): {
+        valid: boolean;
+        error?: string;
+    };
+    /**
+     * Calculate WASM file hash
+     *
+     * @param wasmPath - Path to WASM file
+     * @returns SHA-256 hash as hex string
+     */
+    calculateWasmHash(wasmPath: string): string;
+    /**
+     * Create SHA-256 hash from buffer
+     *
+     * @param buffer - Buffer to hash
+     * @returns Hex-encoded hash
+     */
+    private createSha256Hash;
+    /**
+     * Resolve canister ID from dfx output.
+     */
+    private resolveCanisterId;
+    /**
+     * Parse dfx canister status output (JSON or text output modes).
+     */
+    private parseCanisterStatus;
+    /**
+     * Detect unit test execution environment.
+     */
+    private isTestEnvironment;
+    /**
+     * 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
+     */
+    callAgentMethod<T>(canisterId: string, methodName: string, args?: any[]): Promise<T>;
+    /**
+     * Get stub response for testing
+     */
+    private getStubResponse;
+    /**
+     * Call method via Actor instance
+     */
+    private callViaActor;
+}
+/**
+ * Create ICP client instance
+ *
+ * @param config - Client configuration
+ * @returns Initialized ICP client
+ */
+export declare function createICPClient(config: ICPClientConfig): ICPClient;
+/**
+ * Generate stub canister ID (for testing)
+ *
+ * @returns Random canister ID for local testing
+ */
+export declare function generateStubCanisterId(): string;
+//# sourceMappingURL=icpClient.d.ts.map