agentvault 1.0.1 → 1.0.2

package/dist/src/monitoring/info.js

@@ -0,0 +1,109 @@
+/**
+ * Canister Information
+ *
+ * Queries canister status and metrics using icp-cli.
+ */
+import { canisterStatus } from '../icp/icpcli.js';
+/**
+ * Get detailed canister information.
+ *
+ * @param canisterId - Canister ID to query
+ * @param options - Monitoring options
+ * @returns Canister status information
+ */
+export async function getCanisterInfo(canisterId, _options) {
+    const result = await canisterStatus({ canister: canisterId });
+    const statusInfo = {
+        canisterId,
+        status: result.success ? (result.stdout.match(/Status:\s*(\w+)/)?.[1] ?? 'unknown') : 'unknown',
+        memorySize: parseMemorySize(result.stdout),
+        cycles: parseCycles(result.stdout),
+        moduleHash: extractModuleHash(result.stdout),
+        health: 'healthy',
+        timestamp: new Date(),
+    };
+    return statusInfo;
+}
+/**
+ * Parse memory size from icp-cli output.
+ */
+function parseMemorySize(output) {
+    const match = output.match(/Memory size:\s*([\d,.]+)\s*(bytes?|KB|MB|GB)?/i);
+    if (match && match[1]) {
+        const value = match[1].replace(/,/g, '');
+        const units = (match[2] || 'bytes').toLowerCase();
+        return parseMemoryValue(value, units);
+    }
+    return undefined;
+}
+/**
+ * Parse a memory value with units to bigint bytes.
+ */
+function parseMemoryValue(value, units) {
+    const numeric = parseFloat(value);
+    if (units === 'gb') {
+        return BigInt(Math.round(numeric * 1024 * 1024 * 1024));
+    }
+    else if (units === 'mb') {
+        return BigInt(Math.round(numeric * 1024 * 1024));
+    }
+    else if (units === 'kb') {
+        return BigInt(Math.round(numeric * 1024));
+    }
+    else {
+        return BigInt(Math.round(numeric));
+    }
+}
+/**
+ * Parse cycle balance from icp-cli output.
+ */
+function parseCycles(output) {
+    const match = output.match(/Cycles:\s*([\d,.]+(?:T|B|M|K|G|μ)?)/);
+    if (match && match[1]) {
+        const value = match[1].replace(/,/g, '');
+        const unitsMatch = match[0].match(/(T|B|M|K|G|μ)/);
+        const units = unitsMatch ? unitsMatch[1] : '';
+        if (units) {
+            return parseCycleValue(value, units);
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse a cycle value with units to bigint cycles.
+ */
+function parseCycleValue(value, units) {
+    const numeric = parseFloat(value);
+    if (units === 'T') {
+        return BigInt(Math.round(numeric * 1_000_000_000_000));
+    }
+    else if (units === 'B') {
+        return BigInt(Math.round(numeric));
+    }
+    else if (units === 'M') {
+        return BigInt(Math.round(numeric * 1_000_000));
+    }
+    else if (units === 'K') {
+        return BigInt(Math.round(numeric * 1_000));
+    }
+    else if (units === 'G') {
+        return BigInt(Math.round(numeric * 1_000_000_000));
+    }
+    else if (units === 'μ') {
+        return BigInt(Math.round(numeric / 1_000_000));
+    }
+    else {
+        return BigInt(Math.round(numeric * 1_000));
+    }
+}
+/**
+ * Extract module hash from icp-cli output.
+ */
+function extractModuleHash(output) {
+    const match = output.match(/Hash:\s*([a-f0-9]{64})/);
+    if (match) {
+        return match[1];
+    }
+    return undefined;
+}
+//# sourceMappingURL=info.js.map

package/dist/src/monitoring/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Types for canister monitoring
+ *
+ * Health status, alerts, and resource tracking.
+ */
+/**
+ * Canister health status
+ */
+export type CanisterHealthStatus = 'healthy' | 'warning' | 'critical' | 'unknown';
+/**
+ * Alert severity levels
+ */
+export type AlertSeverity = 'info' | 'warning' | 'critical';
+/**
+ * Monitoring alert
+ */
+export interface MonitoringAlert {
+    /** Alert severity */
+    severity: AlertSeverity;
+    /** Human-readable alert message */
+    message: string;
+    /** Canister ID this alert is for */
+    canisterId: string;
+    /** Metric being monitored */
+    metric: string;
+    /** Current value that triggered alert */
+    value: string;
+    /** Threshold value that was exceeded */
+    threshold: string;
+    /** When the alert was triggered */
+    timestamp: Date;
+}
+/**
+ * Health check thresholds
+ */
+export interface HealthThresholds {
+    /** Cycles below this value trigger a warning */
+    cyclesWarning?: bigint;
+    /** Cycles below this value trigger a critical alert */
+    cyclesCritical?: bigint;
+    /** Memory usage above this percentage triggers a warning (0-100) */
+    memoryWarningPercent?: number;
+    /** Memory usage above this percentage triggers a critical alert (0-100) */
+    memoryCriticalPercent?: number;
+}
+/**
+ * Canister status info from monitoring
+ */
+export interface CanisterStatusInfo {
+    /** Canister ID */
+    canisterId: string;
+    /** Canister status (running, stopped, etc.) */
+    status: string;
+    /** Memory size in bytes */
+    memorySize?: bigint;
+    /** Current cycle balance */
+    cycles?: bigint;
+    /** WASM module hash */
+    moduleHash?: string;
+    /** Health status */
+    health: CanisterHealthStatus;
+    /** Timestamp of when this status was captured */
+    timestamp: Date;
+}
+/**
+ * Resource usage metrics over time
+ */
+export interface ResourceUsageSnapshot {
+    /** Canister ID */
+    canisterId: string;
+    /** Memory usage at this snapshot */
+    memoryBytes?: bigint;
+    /** Cycle balance at this snapshot */
+    cycles?: bigint;
+    /** When this snapshot was captured */
+    timestamp: Date;
+}
+/**
+ * Monitoring query options
+ */
+export interface MonitoringOptions {
+    /** Canister ID or name to monitor */
+    canister: string;
+    /** Alert thresholds */
+    thresholds?: Partial<HealthThresholds>;
+    /** How often to poll (milliseconds) */
+    pollInterval?: number;
+    /** Maximum number of snapshots to keep */
+    maxSnapshots?: number;
+    /** Whether to generate alerts */
+    generateAlerts?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/monitoring/types.js

@@ -0,0 +1,7 @@
+/**
+ * Types for canister monitoring
+ *
+ * Health status, alerts, and resource tracking.
+ */
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,5 @@
+/**
+ * Network management module
+ */
+export * from './network-config.js';
+//# sourceMappingURL=index.d.ts.map

package/{src/network/index.ts → dist/src/network/index.js}

@@ -1,5 +1,5 @@
 /**
  * Network management module
  */
-
 export * from './network-config.js';
+//# sourceMappingURL=index.js.map

package/dist/src/network/network-config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Network configuration management for AgentVault
+ *
+ * Manages local network configurations stored in ~/.agentvault/networks/
+ */
+import type { NetworkConfig } from '../icp/types.js';
+/**
+ * Create a new network configuration
+ */
+export declare function createNetworkConfig(config: NetworkConfig): Promise<NetworkConfig>;
+/**
+ * Get network configuration by name
+ */
+export declare function getNetworkConfig(name: string): Promise<NetworkConfig | null>;
+/**
+ * List all network configurations
+ */
+export declare function listNetworkConfigs(): Promise<NetworkConfig[]>;
+/**
+ * Update network configuration
+ */
+export declare function updateNetworkConfig(name: string, updates: Partial<NetworkConfig>): Promise<NetworkConfig | null>;
+/**
+ * Delete network configuration
+ */
+export declare function deleteNetworkConfig(name: string): Promise<boolean>;
+/**
+ * Set network status
+ */
+export declare function setNetworkStatus(name: string, status: 'running' | 'stopped' | 'error'): Promise<boolean>;
+//# sourceMappingURL=network-config.d.ts.map

package/dist/src/network/network-config.js

@@ -0,0 +1,109 @@
+/**
+ * Network configuration management for AgentVault
+ *
+ * Manages local network configurations stored in ~/.agentvault/networks/
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { parse, stringify } from 'yaml';
+const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
+const NETWORKS_DIR = path.join(AGENTVAULT_DIR, 'networks');
+/**
+ * Ensure the networks directory exists
+ */
+function ensureNetworksDir() {
+    if (!fs.existsSync(AGENTVAULT_DIR)) {
+        fs.mkdirSync(AGENTVAULT_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(NETWORKS_DIR)) {
+        fs.mkdirSync(NETWORKS_DIR, { recursive: true });
+    }
+}
+/**
+ * Get the file path for a network config
+ */
+function getNetworkConfigPath(name) {
+    ensureNetworksDir();
+    return path.join(NETWORKS_DIR, `${name}.yaml`);
+}
+/**
+ * Create a new network configuration
+ */
+export async function createNetworkConfig(config) {
+    const networkPath = getNetworkConfigPath(config.name);
+    if (fs.existsSync(networkPath)) {
+        throw new Error(`Network '${config.name}' already exists`);
+    }
+    const fullConfig = {
+        ...config,
+        created: new Date(),
+        status: 'stopped',
+    };
+    fs.writeFileSync(networkPath, stringify(fullConfig), 'utf8');
+    return fullConfig;
+}
+/**
+ * Get network configuration by name
+ */
+export async function getNetworkConfig(name) {
+    const networkPath = getNetworkConfigPath(name);
+    if (!fs.existsSync(networkPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(networkPath, 'utf8');
+    return parse(content);
+}
+/**
+ * List all network configurations
+ */
+export async function listNetworkConfigs() {
+    ensureNetworksDir();
+    const configs = [];
+    const files = fs.readdirSync(NETWORKS_DIR);
+    for (const file of files) {
+        if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+            const networkPath = path.join(NETWORKS_DIR, file);
+            const content = fs.readFileSync(networkPath, 'utf8');
+            try {
+                configs.push(parse(content));
+            }
+            catch {
+                // Skip invalid config files
+            }
+        }
+    }
+    return configs;
+}
+/**
+ * Update network configuration
+ */
+export async function updateNetworkConfig(name, updates) {
+    const config = await getNetworkConfig(name);
+    if (!config) {
+        return null;
+    }
+    const updated = { ...config, ...updates };
+    const networkPath = getNetworkConfigPath(name);
+    fs.writeFileSync(networkPath, stringify(updated), 'utf8');
+    return updated;
+}
+/**
+ * Delete network configuration
+ */
+export async function deleteNetworkConfig(name) {
+    const networkPath = getNetworkConfigPath(name);
+    if (!fs.existsSync(networkPath)) {
+        return false;
+    }
+    fs.unlinkSync(networkPath);
+    return true;
+}
+/**
+ * Set network status
+ */
+export async function setNetworkStatus(name, status) {
+    const updated = await updateNetworkConfig(name, { status });
+    return updated !== null;
+}
+//# sourceMappingURL=network-config.js.map

package/dist/src/packaging/compiler.d.ts

@@ -0,0 +1,61 @@
+/**
+ * WASM Compilation
+ *
+ * This module provides real WASM compilation for agent code.
+ * It bundles agent source code and creates WebAssembly modules
+ * with embedded JavaScript for execution.
+ */
+import type { AgentConfig, PackageResult, PackageOptions } from './types.js';
+/**
+ * Bundle agent code to JavaScript
+ *
+ * Uses esbuild to bundle the agent's source code into a single JavaScript file.
+ */
+export declare function bundleAgentCode(config: AgentConfig): Promise<string>;
+/**
+ * Generate a real WASM binary with embedded JavaScript bundle
+ *
+ * Creates a WASM module that contains:
+ * - Magic bytes and version
+ * - Custom section with agent metadata
+ * - Data section with embedded JavaScript bundle
+ * - Exported functions for agent lifecycle
+ */
+export declare function generateWasm(config: AgentConfig, javascriptBundle: string): Buffer;
+/**
+ * Generate WAT (WebAssembly Text Format) representation
+ *
+ * Creates a human-readable text representation of the WASM module.
+ */
+export declare function generateStubWat(config: AgentConfig): string;
+/**
+ * Generate serialized state JSON
+ *
+ * Creates the initial state representation for the agent.
+ */
+export declare function generateStateJson(config: AgentConfig): string;
+/**
+ * Generate WAT (WebAssembly Text Format) representation
+ *
+ * Creates a human-readable text representation of the compiled WASM module.
+ */
+export declare function generateWat(config: AgentConfig, javascriptBundle: string): string;
+/**
+ * Compile an agent to WASM using WasmEdge
+ *
+ * This is the main compilation function that orchestrates the packaging process.
+ * It bundles agent code and creates a WASM module with embedded JavaScript.
+ *
+ * @param config - Agent configuration from detection
+ * @param options - Packaging options including compilation target
+ * @param outputDir - Directory to write output files
+ * @returns Package result with paths to generated files
+ */
+export declare function compileToWasm(config: AgentConfig, options: PackageOptions, outputDir: string): Promise<PackageResult>;
+/**
+ * Validate WASM file integrity
+ *
+ * Checks that a file has valid WASM magic bytes.
+ */
+export declare function validateWasmFile(filePath: string): boolean;
+//# sourceMappingURL=compiler.d.ts.map