agentvault 1.0.0 → 1.0.2

package/dist/src/icp/identity.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Identity Management
+ *
+ * Provides identity management via icp-cli.
+ * List identities, create new identities,
+ * import/export identities and manage default identity.
+ */
+/**
+ * List all available identities.
+ *
+ * @returns Command result with identity list
+ */
+export declare function listIdentities(): Promise<any>;
+/**
+ * Create a new identity.
+ *
+ * @param name - Identity name
+ * @returns Command result
+ */
+export declare function createIdentity(name: string): Promise<any>;
+/**
+ * Export an identity to PEM file.
+ *
+ * @param name - Identity name
+ * @returns Command result with PEM content
+ */
+export declare function exportIdentity(name: string): Promise<any>;
+/**
+ * Get the principal of a default or named identity.
+ *
+ * @param name - Identity name (if null, use default)
+ * @returns Command result with principal
+ */
+export declare function getIdentityPrincipal(name?: string): Promise<string>;
+/**
+ * Import an identity from a PEM file.
+ *
+ * @param name - Identity name to import
+ * @param pemFile - Path to PEM file
+ * @returns Command result
+ */
+export declare function importIdentity(name: string, pemFile: string): Promise<any>;
+/**
+ * Set a default identity.
+ *
+ * @param name - Identity name to set as default
+ * @returns Command result
+ */
+export declare function setDefaultIdentity(name: string): Promise<any>;
+//# sourceMappingURL=identity.d.ts.map

package/{src/icp/identity.ts → dist/src/icp/identity.js}

@@ -5,56 +5,43 @@
  * List identities, create new identities,
  * import/export identities and manage default identity.
  */
-
-import {
-  identityList,
-  identityNew,
-  identityExport,
-  identityPrincipal,
-  identityImport,
-  identityDefault,
-} from './icpcli.js';
-
+import { identityList, identityNew, identityExport, identityPrincipal, identityImport, identityDefault, } from './icpcli.js';
 /**
  * List all available identities.
  *
  * @returns Command result with identity list
  */
-export async function listIdentities(): Promise<any> {
-  return identityList({});
+export async function listIdentities() {
+    return identityList({});
 }
-
 /**
  * Create a new identity.
  *
  * @param name - Identity name
  * @returns Command result
  */
-export async function createIdentity(name: string): Promise<any> {
-  return identityNew({ name });
+export async function createIdentity(name) {
+    return identityNew({ name });
 }
-
 /**
  * Export an identity to PEM file.
  *
  * @param name - Identity name
  * @returns Command result with PEM content
  */
-export async function exportIdentity(name: string): Promise<any> {
-  return identityExport({ name });
+export async function exportIdentity(name) {
+    return identityExport({ name });
 }
-
 /**
  * Get the principal of a default or named identity.
  *
  * @param name - Identity name (if null, use default)
  * @returns Command result with principal
  */
-export async function getIdentityPrincipal(name?: string): Promise<string> {
-  const result = await identityPrincipal({ name });
-  return result.stdout || '';
+export async function getIdentityPrincipal(name) {
+    const result = await identityPrincipal({ name });
+    return result.stdout || '';
 }
-
 /**
  * Import an identity from a PEM file.
  *
@@ -62,16 +49,16 @@ export async function getIdentityPrincipal(name?: string): Promise<string> {
  * @param pemFile - Path to PEM file
  * @returns Command result
  */
-export async function importIdentity(name: string, pemFile: string): Promise<any> {
-  return identityImport({ name, pemFile });
+export async function importIdentity(name, pemFile) {
+    return identityImport({ name, pemFile });
 }
-
 /**
  * Set a default identity.
  *
  * @param name - Identity name to set as default
  * @returns Command result
  */
-export async function setDefaultIdentity(name: string): Promise<any> {
-  return identityDefault({ name });
+export async function setDefaultIdentity(name) {
+    return identityDefault({ name });
 }
+//# sourceMappingURL=identity.js.map

package/dist/src/icp/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ICP Tools Integration Module
+ *
+ * Provides typed wrappers around ic-wasm and icp-cli tooling,
+ * auto-detection of available tools, an optimization pipeline,
+ * and environment management.
+ */
+export type { ToolName, ToolInfo, ToolchainStatus, IcWasmOptLevel, IcWasmOptimizeOptions, IcWasmShrinkOptions, IcWasmResourceOptions, IcWasmMetadataOptions, IcWasmCheckEndpointsOptions, IcWasmInstrumentOptions, IcWasmResult, IcWasmInfo, MetadataVisibility, IcWasmOptimizationResult, IcWasmOptimizationPipelineOptions, IcWasmOptimizationPipelineResult, IcpEnvironment, IcpDeployMode, IcpCommonOptions, IcpBuildOptions, IcpDeployOptions, IcpCanisterStatusOptions, IcpCanisterCallOptions, IcpCyclesBalanceOptions, IcpCyclesMintOptions, IcpCyclesTransferOptions, IcpIdentityListOptions, IcpIdentityNewOptions, IcpIdentityExportOptions, IcpIdentityImportOptions, IcpNetworkStartOptions, IcpNetworkStopOptions, IcpSyncOptions, IcpTokenBalanceOptions, IcpTokenTransferOptions, IcpEnvironmentListOptions, IcpCliResult, IcpNetworkConfig, IcpCyclesConfig, IcpEnvironmentConfig, IcpOptimizationConfig, IcpProjectConfig, } from './types.js';
+export type { CanisterHealthStatus, AlertSeverity, CanisterStatusInfo, MonitoringAlert, HealthThresholds, MonitoringOptions, ResourceUsageSnapshot, } from '../monitoring/types.js';
+export { detectTool, detectToolchain, requireTool, } from './tool-detector.js';
+export * as icwasm from './icwasm.js';
+export * as icpcli from './icpcli.js';
+export { runOptimizationPipeline } from './optimization.js';
+export { findConfigFile, loadConfig, getEnvironment, getOptimizationConfig, listEnvironments, writeConfig, generateDefaultConfig, } from './environment.js';
+export * from './batch.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/icp/index.js

@@ -0,0 +1,20 @@
+/**
+ * ICP Tools Integration Module
+ *
+ * Provides typed wrappers around ic-wasm and icp-cli tooling,
+ * auto-detection of available tools, an optimization pipeline,
+ * and environment management.
+ */
+// Tool detection
+export { detectTool, detectToolchain, requireTool, } from './tool-detector.js';
+// ic-wasm wrapper
+export * as icwasm from './icwasm.js';
+// icp-cli wrapper
+export * as icpcli from './icpcli.js';
+// Optimization pipeline
+export { runOptimizationPipeline } from './optimization.js';
+// Environment management
+export { findConfigFile, loadConfig, getEnvironment, getOptimizationConfig, listEnvironments, writeConfig, generateDefaultConfig, } from './environment.js';
+// Batched canister operations
+export * from './batch.js';
+//# sourceMappingURL=index.js.map

package/dist/src/icp/optimization.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Optimization Pipeline
+ *
+ * Orchestrates ic-wasm optimize, shrink, resource limiting, metadata
+ * injection, and Candid validation into a single pipeline that runs
+ * after WASM generation in the packaging step.
+ */
+import type { IcWasmOptimizationPipelineOptions, IcWasmOptimizationPipelineResult } from './types.js';
+/**
+ * Run the full optimization pipeline on a WASM file.
+ *
+ * @param options - Pipeline options
+ * @returns Pipeline result with metrics
+ */
+export declare function runOptimizationPipeline(options: IcWasmOptimizationPipelineOptions): Promise<IcWasmOptimizationPipelineResult>;
+//# sourceMappingURL=optimization.d.ts.map

package/dist/src/icp/optimization.js

@@ -0,0 +1,225 @@
+/**
+ * Optimization Pipeline
+ *
+ * Orchestrates ic-wasm optimize, shrink, resource limiting, metadata
+ * injection, and Candid validation into a single pipeline that runs
+ * after WASM generation in the packaging step.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { detectTool } from './tool-detector.js';
+import * as icwasm from './icwasm.js';
+/**
+ * Run the full optimization pipeline on a WASM file.
+ *
+ * @param options - Pipeline options
+ * @returns Pipeline result with metrics
+ */
+export async function runOptimizationPipeline(options) {
+    const startTime = Date.now();
+    const steps = [];
+    const warnings = [];
+    let currentInput = options.input;
+    // Verify input exists
+    if (!fs.existsSync(options.input)) {
+        return {
+            success: false,
+            outputPath: options.output,
+            originalSize: 0,
+            finalSize: 0,
+            reductionPercent: 0,
+            totalDurationMs: Date.now() - startTime,
+            steps: [],
+            warnings: [`Input file not found: ${options.input}`],
+        };
+    }
+    const originalSize = fs.statSync(options.input).size;
+    // Check if ic-wasm is available
+    const icWasmTool = await detectTool('ic-wasm');
+    if (!icWasmTool.available) {
+        // No optimization possible - copy input to output
+        fs.copyFileSync(options.input, options.output);
+        warnings.push('ic-wasm not found; skipping optimization. Install with: cargo install ic-wasm');
+        return {
+            success: true,
+            outputPath: options.output,
+            originalSize,
+            finalSize: originalSize,
+            reductionPercent: 0,
+            totalDurationMs: Date.now() - startTime,
+            steps: [],
+            warnings,
+        };
+    }
+    // Create temp directory for intermediate files
+    const tempDir = path.join(path.dirname(options.output), '.icp-optimize-tmp');
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+    }
+    let tempCounter = 0;
+    function nextTemp() {
+        return path.join(tempDir, `step_${++tempCounter}.wasm`);
+    }
+    // Step 1: Shrink
+    if (options.shrink !== false) {
+        const stepStart = Date.now();
+        const tempOut = nextTemp();
+        const result = await icwasm.shrink({ input: currentInput, output: tempOut });
+        const step = {
+            step: 'shrink',
+            success: result.success,
+            durationMs: Date.now() - stepStart,
+            sizeAfter: undefined,
+            error: undefined,
+        };
+        if (result.success && fs.existsSync(tempOut)) {
+            step.sizeAfter = fs.statSync(tempOut).size;
+            currentInput = tempOut;
+        }
+        else {
+            step.error = result.stderr || 'Shrink failed';
+            warnings.push(`Shrink step failed: ${step.error}`);
+        }
+        steps.push(step);
+    }
+    // Step 2: Optimize
+    if (options.optimize !== false) {
+        const stepStart = Date.now();
+        const tempOut = nextTemp();
+        const level = options.optimizeLevel ?? 'O3';
+        const result = await icwasm.optimize({
+            input: currentInput,
+            output: tempOut,
+            level,
+        });
+        const step = {
+            step: `optimize (${level})`,
+            success: result.success,
+            durationMs: Date.now() - stepStart,
+            sizeAfter: undefined,
+            error: undefined,
+        };
+        if (result.success && fs.existsSync(tempOut)) {
+            step.sizeAfter = fs.statSync(tempOut).size;
+            currentInput = tempOut;
+        }
+        else {
+            step.error = result.stderr || 'Optimize failed';
+            warnings.push(`Optimize step failed: ${step.error}`);
+        }
+        steps.push(step);
+    }
+    // Step 3: Resource limits
+    if (options.resourceLimits && Object.keys(options.resourceLimits).length > 0) {
+        for (const [name, value] of Object.entries(options.resourceLimits)) {
+            const stepStart = Date.now();
+            const tempOut = nextTemp();
+            const result = await icwasm.setResource({
+                input: currentInput,
+                output: tempOut,
+                name,
+                value,
+            });
+            const step = {
+                step: `resource (${name}=${value})`,
+                success: result.success,
+                durationMs: Date.now() - stepStart,
+                sizeAfter: undefined,
+                error: undefined,
+            };
+            if (result.success && fs.existsSync(tempOut)) {
+                step.sizeAfter = fs.statSync(tempOut).size;
+                currentInput = tempOut;
+            }
+            else {
+                step.error = result.stderr || 'Resource limit failed';
+                warnings.push(`Resource limit '${name}' failed: ${step.error}`);
+            }
+            steps.push(step);
+        }
+    }
+    // Step 4: Metadata injection
+    if (options.metadata && options.metadata.length > 0) {
+        for (const meta of options.metadata) {
+            const stepStart = Date.now();
+            const tempOut = nextTemp();
+            const result = await icwasm.setMetadata({
+                input: currentInput,
+                output: tempOut,
+                name: meta.name,
+                data: meta.data,
+                visibility: meta.visibility,
+            });
+            const step = {
+                step: `metadata (${meta.name})`,
+                success: result.success,
+                durationMs: Date.now() - stepStart,
+                sizeAfter: undefined,
+                error: undefined,
+            };
+            if (result.success && fs.existsSync(tempOut)) {
+                step.sizeAfter = fs.statSync(tempOut).size;
+                currentInput = tempOut;
+            }
+            else {
+                step.error = result.stderr || 'Metadata set failed';
+                warnings.push(`Metadata '${meta.name}' failed: ${step.error}`);
+            }
+            steps.push(step);
+        }
+    }
+    // Step 5: Candid validation (does not produce output, just validates)
+    let validationPassed;
+    if (options.candidInterface) {
+        const stepStart = Date.now();
+        const result = await icwasm.checkEndpoints({
+            input: currentInput,
+            candidInterface: options.candidInterface,
+        });
+        validationPassed = result.success;
+        const step = {
+            step: 'check-endpoints',
+            success: result.success,
+            durationMs: Date.now() - stepStart,
+            sizeAfter: undefined,
+            error: undefined,
+        };
+        if (!result.success) {
+            step.error = result.stderr || 'Endpoint validation failed';
+            warnings.push(`Candid validation failed: ${step.error}`);
+        }
+        steps.push(step);
+    }
+    // Move final result to output path
+    if (currentInput !== options.input) {
+        fs.copyFileSync(currentInput, options.output);
+    }
+    else {
+        // No steps modified the file; copy input to output
+        fs.copyFileSync(options.input, options.output);
+    }
+    const finalSize = fs.statSync(options.output).size;
+    // Cleanup temp directory
+    try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+    const reductionPercent = originalSize > 0
+        ? Math.round(((originalSize - finalSize) / originalSize) * 100)
+        : 0;
+    const allStepsSucceeded = steps.every((s) => s.success);
+    return {
+        success: allStepsSucceeded,
+        outputPath: options.output,
+        originalSize,
+        finalSize,
+        reductionPercent,
+        totalDurationMs: Date.now() - startTime,
+        steps,
+        validationPassed,
+        warnings,
+    };
+}
+//# sourceMappingURL=optimization.js.map

package/dist/src/icp/tokens.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Token Operations
+ *
+ * Provides token operations via icp-cli.
+ * Supports ICP and ICRC-1/ICRC-2 tokens.
+ */
+/**
+ * Check token balance for a canister.
+ *
+ * @param canister - Token canister ID
+ * @param options - Common ICP options
+ * @returns Command result with balance
+ */
+export declare function checkBalance(canister: string): Promise<any>;
+/**
+ * Transfer tokens to a recipient.
+ *
+ * @param amount - Amount to transfer
+ * @param to - Recipient principal or account
+ * @param options - Common ICP options
+ * @returns Command result
+ */
+export declare function transferTokens(amount: string, to: string): Promise<any>;
+//# sourceMappingURL=tokens.d.ts.map

package/{src/icp/tokens.ts → dist/src/icp/tokens.js}

@@ -4,9 +4,7 @@
  * Provides token operations via icp-cli.
  * Supports ICP and ICRC-1/ICRC-2 tokens.
  */
-
 import { tokenBalance, tokenTransfer } from './icpcli.js';
-
 /**
  * Check token balance for a canister.
  *
@@ -14,12 +12,9 @@ import { tokenBalance, tokenTransfer } from './icpcli.js';
  * @param options - Common ICP options
  * @returns Command result with balance
  */
-export async function checkBalance(
-  canister: string,
-): Promise<any> {
-  return tokenBalance({ canister });
+export async function checkBalance(canister) {
+    return tokenBalance({ canister });
 }
-
 /**
  * Transfer tokens to a recipient.
  *
@@ -28,9 +23,7 @@ export async function checkBalance(
  * @param options - Common ICP options
  * @returns Command result
  */
-export async function transferTokens(
-  amount: string,
-  to: string,
-): Promise<any> {
-  return tokenTransfer({ amount, to });
+export async function transferTokens(amount, to) {
+    return tokenTransfer({ amount, to });
 }
+//# sourceMappingURL=tokens.js.map

package/dist/src/icp/tool-detector.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tool Detector
+ *
+ * Auto-detects availability of ICP tools (ic-wasm, icp, dfx)
+ * on the current system. Used for hybrid compatibility strategy:
+ * prefer icp-cli when available, fall back to dfx.
+ */
+import type { ToolName, ToolInfo, ToolchainStatus } from './types.js';
+/**
+ * Detect whether a single tool is installed and get its version.
+ *
+ * @param name - Tool binary name
+ * @returns ToolInfo with availability, path, and version
+ */
+export declare function detectTool(name: ToolName): Promise<ToolInfo>;
+/**
+ * Detect all ICP tools and determine the preferred toolchain.
+ *
+ * @returns Complete toolchain status
+ */
+export declare function detectToolchain(): Promise<ToolchainStatus>;
+/**
+ * Require a specific tool, throwing a descriptive error if not found.
+ *
+ * @param name - Tool to require
+ * @param purpose - Human-readable description of why it's needed
+ * @returns ToolInfo (guaranteed available)
+ * @throws Error if tool is not available
+ */
+export declare function requireTool(name: ToolName, purpose: string): Promise<ToolInfo>;
+//# sourceMappingURL=tool-detector.d.ts.map

package/dist/src/icp/tool-detector.js

@@ -0,0 +1,104 @@
+/**
+ * Tool Detector
+ *
+ * Auto-detects availability of ICP tools (ic-wasm, icp, dfx)
+ * on the current system. Used for hybrid compatibility strategy:
+ * prefer icp-cli when available, fall back to dfx.
+ */
+import { execaCommand } from 'execa';
+/**
+ * Detect whether a single tool is installed and get its version.
+ *
+ * @param name - Tool binary name
+ * @returns ToolInfo with availability, path, and version
+ */
+export async function detectTool(name) {
+    const result = { name, available: false };
+    // Locate the binary
+    try {
+        const whichResult = await execaCommand(`which ${name}`, {
+            reject: false,
+            timeout: 5000,
+        });
+        if (whichResult.exitCode === 0 && whichResult.stdout.trim()) {
+            result.path = whichResult.stdout.trim();
+        }
+        else {
+            return result;
+        }
+    }
+    catch {
+        return result;
+    }
+    // Get the version
+    try {
+        const versionResult = await execaCommand(`${name} --version`, {
+            reject: false,
+            timeout: 5000,
+        });
+        if (versionResult.exitCode === 0) {
+            const output = versionResult.stdout.trim() || versionResult.stderr.trim();
+            // Extract version number from output like "ic-wasm 0.9.11" or "icp 0.1.0" or "dfx 0.25.0"
+            const match = output.match(/(\d+\.\d+\.\d+)/);
+            if (match) {
+                result.version = match[1];
+            }
+            else {
+                result.version = output;
+            }
+            result.available = true;
+        }
+    }
+    catch {
+        // Binary exists but version check failed - still mark as available
+        result.available = !!result.path;
+    }
+    return result;
+}
+/**
+ * Detect all ICP tools and determine the preferred toolchain.
+ *
+ * @returns Complete toolchain status
+ */
+export async function detectToolchain() {
+    const [icWasm, icp, dfx] = await Promise.all([
+        detectTool('ic-wasm'),
+        detectTool('icp'),
+        detectTool('dfx'),
+    ]);
+    let preferredDeployTool = null;
+    if (icp.available) {
+        preferredDeployTool = 'icp';
+    }
+    else if (dfx.available) {
+        preferredDeployTool = 'dfx';
+    }
+    return {
+        icWasm,
+        icp,
+        dfx,
+        preferredDeployTool,
+        canOptimize: icWasm.available,
+    };
+}
+/**
+ * Require a specific tool, throwing a descriptive error if not found.
+ *
+ * @param name - Tool to require
+ * @param purpose - Human-readable description of why it's needed
+ * @returns ToolInfo (guaranteed available)
+ * @throws Error if tool is not available
+ */
+export async function requireTool(name, purpose) {
+    const tool = await detectTool(name);
+    if (!tool.available) {
+        const installHints = {
+            'ic-wasm': 'Install with: cargo install ic-wasm',
+            'icp': 'Install from: https://github.com/dfinity/icp-cli',
+            'dfx': 'Install with: sh -ci "$(curl -fsSL https://sdk.dfinity.org/install.sh)"',
+        };
+        throw new Error(`Tool '${name}' is required for ${purpose} but was not found.\n${installHints[name]}`);
+    }
+    return tool;
+}
+//# sourceMappingURL=tool-detector.js.map