agentvault 1.0.0

package/src/monitoring/info.ts

@@ -0,0 +1,114 @@
+/**
+ * Canister Information
+ *
+ * Queries canister status and metrics using icp-cli.
+ */
+
+import { canisterStatus } from '../icp/icpcli.js';
+import type { CanisterStatusInfo, MonitoringOptions } from './types.js';
+
+/**
+ * Get detailed canister information.
+ *
+ * @param canisterId - Canister ID to query
+ * @param options - Monitoring options
+ * @returns Canister status information
+ */
+export async function getCanisterInfo(
+  canisterId: string,
+  _options: MonitoringOptions,
+): Promise<CanisterStatusInfo> {
+  const result = await canisterStatus({ canister: canisterId });
+
+  const statusInfo: CanisterStatusInfo = {
+    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: string): bigint | undefined {
+  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: string, units: string): bigint {
+  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: string): bigint | undefined {
+  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: string, units: string): bigint {
+  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: string): string | undefined {
+  const match = output.match(/Hash:\s*([a-f0-9]{64})/);
+  if (match) {
+    return match[1];
+  }
+  return undefined;
+}

package/src/monitoring/types.ts

@@ -0,0 +1,99 @@
+/**
+ * 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;
+}

package/src/network/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Network management module
+ */
+
+export * from './network-config.js';

package/src/network/network-config.ts

@@ -0,0 +1,129 @@
+/**
+ * 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';
+import type { NetworkConfig } from '../icp/types.js';
+
+const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
+const NETWORKS_DIR = path.join(AGENTVAULT_DIR, 'networks');
+
+/**
+ * Ensure the networks directory exists
+ */
+function ensureNetworksDir(): void {
+  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: string): string {
+  ensureNetworksDir();
+  return path.join(NETWORKS_DIR, `${name}.yaml`);
+}
+
+/**
+ * Create a new network configuration
+ */
+export async function createNetworkConfig(config: NetworkConfig): Promise<NetworkConfig> {
+  const networkPath = getNetworkConfigPath(config.name);
+  
+  if (fs.existsSync(networkPath)) {
+    throw new Error(`Network '${config.name}' already exists`);
+  }
+  
+  const fullConfig: NetworkConfig = {
+    ...config,
+    created: new Date(),
+    status: 'stopped',
+  };
+  
+  fs.writeFileSync(networkPath, stringify(fullConfig), 'utf8');
+  return fullConfig;
+}
+
+/**
+ * Get network configuration by name
+ */
+export async function getNetworkConfig(name: string): Promise<NetworkConfig | null> {
+  const networkPath = getNetworkConfigPath(name);
+  
+  if (!fs.existsSync(networkPath)) {
+    return null;
+  }
+  
+  const content = fs.readFileSync(networkPath, 'utf8');
+  return parse(content) as NetworkConfig;
+}
+
+/**
+ * List all network configurations
+ */
+export async function listNetworkConfigs(): Promise<NetworkConfig[]> {
+  ensureNetworksDir();
+  const configs: NetworkConfig[] = [];
+  
+  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) as NetworkConfig);
+      } catch {
+        // Skip invalid config files
+      }
+    }
+  }
+  
+  return configs;
+}
+
+/**
+ * Update network configuration
+ */
+export async function updateNetworkConfig(name: string, updates: Partial<NetworkConfig>): Promise<NetworkConfig | null> {
+  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: string): Promise<boolean> {
+  const networkPath = getNetworkConfigPath(name);
+  
+  if (!fs.existsSync(networkPath)) {
+    return false;
+  }
+  
+  fs.unlinkSync(networkPath);
+  return true;
+}
+
+/**
+ * Set network status
+ */
+export async function setNetworkStatus(name: string, status: 'running' | 'stopped' | 'error'): Promise<boolean> {
+  const updated = await updateNetworkConfig(name, { status });
+  return updated !== null;
+}