agentvault 1.0.1 → 1.0.2

package/{src/cloud-storage/types.ts → dist/src/cloud-storage/types.d.ts}

@@ -6,99 +6,86 @@
  * storage providers (Google Drive, iCloud, Dropbox, etc.)
  * via their local sync directories — no crypto required.
  */
-
 /**
  * Supported cloud storage providers detected via local sync directories.
  */
-export type CloudProvider =
-  | 'google-drive'
-  | 'icloud-drive'
-  | 'dropbox'
-  | 'onedrive'
-  | 'custom';
-
+export type CloudProvider = 'google-drive' | 'icloud-drive' | 'dropbox' | 'onedrive' | 'custom';
 /**
  * A detected cloud provider with its local sync path.
  */
 export interface DetectedProvider {
-  provider: CloudProvider;
-  label: string;
-  path: string;
-  available: boolean;
+    provider: CloudProvider;
+    label: string;
+    path: string;
+    available: boolean;
 }
-
 /**
  * Configuration for cloud backup destination.
  */
 export interface CloudBackupConfig {
-  provider: CloudProvider;
-  basePath: string;
-  subdirectory: string;
+    provider: CloudProvider;
+    basePath: string;
+    subdirectory: string;
 }
-
 /**
  * What to include in a cloud backup archive.
  */
 export interface CloudArchiveOptions {
-  agentName?: string;
-  includeConfigs: boolean;
-  includeWallets: boolean;
-  includeBackups: boolean;
-  includeNetworks: boolean;
+    agentName?: string;
+    includeConfigs: boolean;
+    includeWallets: boolean;
+    includeBackups: boolean;
+    includeNetworks: boolean;
 }
-
 /**
  * Metadata written alongside the archive for identification and integrity.
  */
 export interface CloudArchiveManifest {
-  version: string;
-  createdAt: string;
-  platform: string;
-  hostname: string;
-  agentVaultVersion: string;
-  agentName?: string;
-  components: string[];
-  files: CloudArchiveFileEntry[];
-  checksum: string;
+    version: string;
+    createdAt: string;
+    platform: string;
+    hostname: string;
+    agentVaultVersion: string;
+    agentName?: string;
+    components: string[];
+    files: CloudArchiveFileEntry[];
+    checksum: string;
 }
-
 /**
  * Entry for a single file within the archive manifest.
  */
 export interface CloudArchiveFileEntry {
-  relativePath: string;
-  sizeBytes: number;
-  checksum: string;
+    relativePath: string;
+    sizeBytes: number;
+    checksum: string;
 }
-
 /**
  * Result of an archive operation.
  */
 export interface CloudArchiveResult {
-  success: boolean;
-  archivePath?: string;
-  manifestPath?: string;
-  fileCount?: number;
-  totalBytes?: number;
-  error?: string;
+    success: boolean;
+    archivePath?: string;
+    manifestPath?: string;
+    fileCount?: number;
+    totalBytes?: number;
+    error?: string;
 }
-
 /**
  * Result of a restore operation.
  */
 export interface CloudRestoreResult {
-  success: boolean;
-  restoredFiles?: number;
-  components?: string[];
-  warnings: string[];
-  error?: string;
+    success: boolean;
+    restoredFiles?: number;
+    components?: string[];
+    warnings: string[];
+    error?: string;
 }
-
 /**
  * A discovered archive available for restore.
  */
 export interface DiscoveredArchive {
-  manifestPath: string;
-  archivePath: string;
-  manifest: CloudArchiveManifest;
+    manifestPath: string;
+    archivePath: string;
+    manifest: CloudArchiveManifest;
 }
+//# sourceMappingURL=types.d.ts.map

package/dist/src/cloud-storage/types.js

@@ -0,0 +1,10 @@
+/**
+ * Cloud Storage Types
+ *
+ * Types for the cloud storage backup feature that lets users
+ * archive and restore AgentVault data using consumer cloud
+ * storage providers (Google Drive, iCloud, Dropbox, etc.)
+ * via their local sync directories — no crypto required.
+ */
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * Debugging module
+ */
+export * from './types.js';
+export * from './logs.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,6 +1,6 @@
 /**
  * Debugging module
  */
-
 export * from './types.js';
 export * from './logs.js';
+//# sourceMappingURL=index.js.map

package/dist/src/debugging/logs.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Log aggregation for canister debugging
+ *
+ * Collects, stores, and queries logs from canisters
+ */
+import type { LogEntry, LogLevel } from './types.js';
+/**
+ * Collect logs from canister output
+ */
+export declare function collectLogs(canisterId: string, output: string): Promise<LogEntry[]>;
+/**
+ * Store log entries to disk
+ */
+export declare function storeLogs(canisterId: string, logs: LogEntry[]): Promise<void>;
+/**
+ * Retrieve logs for a canister with optional filtering
+ */
+export declare function getLogs(canisterId: string, options?: {
+    since?: Date;
+    level?: LogLevel;
+    pattern?: string;
+    limit?: number;
+}): Promise<LogEntry[]>;
+/**
+ * Export logs to a file
+ */
+export declare function exportLogs(canisterId: string, outputPath: string, format?: 'json' | 'csv'): Promise<void>;
+/**
+ * Clear logs for a canister
+ */
+export declare function clearLogs(canisterId: string): Promise<void>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/src/debugging/logs.js

@@ -0,0 +1,158 @@
+/**
+ * Log aggregation for canister debugging
+ *
+ * Collects, stores, and queries logs from canisters
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
+const LOGS_DIR = path.join(AGENTVAULT_DIR, 'logs');
+/**
+ * Ensure logs directory exists
+ */
+function ensureLogsDir() {
+    if (!fs.existsSync(AGENTVAULT_DIR)) {
+        fs.mkdirSync(AGENTVAULT_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(LOGS_DIR)) {
+        fs.mkdirSync(LOGS_DIR, { recursive: true });
+    }
+}
+/**
+ * Get logs directory for a specific canister
+ */
+function getCanisterLogsDir(canisterId) {
+    ensureLogsDir();
+    const canisterDir = path.join(LOGS_DIR, canisterId);
+    if (!fs.existsSync(canisterDir)) {
+        fs.mkdirSync(canisterDir, { recursive: true });
+    }
+    return canisterDir;
+}
+/**
+ * Get log file path for a canister and date
+ */
+function getLogFilePath(canisterId, date) {
+    const logsDir = getCanisterLogsDir(canisterId);
+    const logDate = date || new Date();
+    const dateStr = logDate.toISOString().split('T')[0];
+    return path.join(logsDir, `${dateStr}.jsonl`);
+}
+/**
+ * Parse log line from canister output
+ */
+function parseLogLine(line, canisterId) {
+    try {
+        const parsed = JSON.parse(line);
+        return {
+            timestamp: new Date(parsed.timestamp),
+            level: parsed.level || 'info',
+            message: parsed.message || '',
+            canisterId,
+            method: parsed.method,
+            context: parsed.context,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Collect logs from canister output
+ */
+export async function collectLogs(canisterId, output) {
+    const logs = [];
+    const lines = output.split('\n');
+    for (const line of lines) {
+        if (line.trim()) {
+            const logEntry = parseLogLine(line, canisterId);
+            if (logEntry) {
+                logs.push(logEntry);
+            }
+        }
+    }
+    return logs;
+}
+/**
+ * Store log entries to disk
+ */
+export async function storeLogs(canisterId, logs) {
+    const logFilePath = getLogFilePath(canisterId);
+    const lines = logs.map((log) => JSON.stringify(log)).join('\n');
+    fs.appendFileSync(logFilePath, lines + '\n', 'utf8');
+}
+/**
+ * Retrieve logs for a canister with optional filtering
+ */
+export async function getLogs(canisterId, options = {}) {
+    const logsDir = getCanisterLogsDir(canisterId);
+    const files = fs.readdirSync(logsDir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .sort()
+        .reverse();
+    const allLogs = [];
+    for (const file of files) {
+        const filePath = path.join(logsDir, file);
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            if (line.trim()) {
+                const log = parseLogLine(line, canisterId);
+                if (log) {
+                    allLogs.push(log);
+                }
+            }
+        }
+        if (options.since) {
+            const fileDate = new Date(file.replace('.jsonl', ''));
+            if (fileDate < options.since) {
+                break;
+            }
+        }
+    }
+    const filteredLogs = allLogs.filter((log) => {
+        if (options.since && log.timestamp < options.since) {
+            return false;
+        }
+        if (options.level && log.level !== options.level) {
+            return false;
+        }
+        if (options.pattern && !log.message.includes(options.pattern)) {
+            return false;
+        }
+        return true;
+    });
+    if (options.limit) {
+        return filteredLogs.slice(-options.limit);
+    }
+    return filteredLogs.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+}
+/**
+ * Export logs to a file
+ */
+export async function exportLogs(canisterId, outputPath, format = 'json') {
+    const logs = await getLogs(canisterId);
+    if (format === 'json') {
+        fs.writeFileSync(outputPath, JSON.stringify(logs, null, 2), 'utf8');
+    }
+    else if (format === 'csv') {
+        const headers = 'timestamp,level,message,canisterId,method,context\n';
+        const rows = logs.map((log) => {
+            const context = log.context ? JSON.stringify(log.context).replace(/"/g, '""') : '';
+            return `"${log.timestamp.toISOString()}","${log.level}","${log.message.replace(/"/g, '""')}","${log.canisterId}","${log.method || ''}","${context}"`;
+        }).join('\n');
+        fs.writeFileSync(outputPath, headers + rows, 'utf8');
+    }
+}
+/**
+ * Clear logs for a canister
+ */
+export async function clearLogs(canisterId) {
+    const logsDir = getCanisterLogsDir(canisterId);
+    const files = fs.readdirSync(logsDir);
+    for (const file of files) {
+        fs.unlinkSync(path.join(logsDir, file));
+    }
+}
+//# sourceMappingURL=logs.js.map

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

@@ -0,0 +1,91 @@
+/**
+ * Types for debugging and instrumentation functionality
+ */
+/** Log level */
+export type LogLevel = 'info' | 'warning' | 'error' | 'debug';
+/** Log entry from canister or system */
+export interface LogEntry {
+    /** Log timestamp */
+    timestamp: Date;
+    /** Log level */
+    level: LogLevel;
+    /** Log message */
+    message: string;
+    /** Source canister ID */
+    canisterId: string;
+    /** Method that generated the log (if applicable) */
+    method?: string;
+    /** Additional context */
+    context?: Record<string, unknown>;
+}
+/** Trace filter options */
+export interface TraceFilter {
+    /** Filter by method name */
+    method?: string;
+    /** Minimum duration in milliseconds */
+    minDuration?: number;
+    /** Maximum depth of the call tree */
+    maxDepth?: number;
+    /** Filter by caller principal */
+    caller?: string;
+}
+/** Method statistics for profiling */
+export interface MethodStats {
+    /** Number of calls */
+    count: number;
+    /** Total duration in milliseconds */
+    totalDuration: number;
+    /** Average duration in milliseconds */
+    avgDuration: number;
+    /** Maximum duration in milliseconds */
+    maxDuration: number;
+}
+/** Result of profiling a canister */
+export interface ProfileResult {
+    /** Number of samples collected */
+    samples: number;
+    /** Duration of profiling in seconds */
+    duration: number;
+    /** Statistics per method */
+    methodStats: Map<string, MethodStats>;
+    /** Memory snapshots taken during profiling */
+    memorySnapshots: number[];
+}
+/** Instrument result */
+export interface InstrumentResult {
+    /** Whether instrumentation succeeded */
+    success: boolean;
+    /** Path to instrumented WASM */
+    outputPath: string;
+    /** Any warnings from instrumentation */
+    warnings: string[];
+}
+/** Trace export format */
+export type TraceExportFormat = 'json' | 'flamegraph' | 'text';
+/** Dashboard metric types */
+export interface DashboardMetrics {
+    /** Current cycles balance */
+    cycles: bigint;
+    /** Memory usage in bytes */
+    memory: bigint;
+    /** Requests per second */
+    requestRate: number;
+    /** Error rate */
+    errorRate: number;
+}
+/** Alert severity levels */
+export type AlertSeverity = 'info' | 'warning' | 'error' | 'critical';
+/** Alert entry */
+export interface AlertEntry {
+    /** Alert timestamp */
+    timestamp: Date;
+    /** Alert severity */
+    severity: AlertSeverity;
+    /** Alert message */
+    message: string;
+    /** Related canister ID */
+    canisterId: string;
+    /** Alert type/category */
+    type: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/debugging/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for debugging and instrumentation functionality
+ */
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,52 @@
+/**
+ * Agent Deployer
+ *
+ * Main orchestrator for the ICP canister deployment pipeline.
+ * Coordinates validation, client setup, and deployment operations.
+ */
+import type { DeployOptions, DeployResult, DeploymentError, NetworkType, DeploymentStatus } from './types.js';
+/**
+ * Validate deployment options
+ */
+export declare function validateDeployOptions(options: DeployOptions): {
+    valid: boolean;
+    errors: DeploymentError[];
+    warnings: string[];
+};
+/**
+ * Get deployment preview/summary
+ *
+ * Useful for dry-run functionality
+ */
+export declare function getDeploySummary(options: DeployOptions): {
+    agentName: string;
+    wasmPath: string;
+    wasmHash: string;
+    wasmSize: number;
+    network: NetworkType;
+    isUpgrade: boolean;
+    canisterId?: string;
+    validation: ReturnType<typeof validateDeployOptions>;
+};
+/**
+ * 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 declare function deployAgent(options: DeployOptions): Promise<DeployResult>;
+/**
+ * Check if a canister exists and get its status
+ */
+export declare function getCanisterStatus(canisterId: string, network: NetworkType): Promise<{
+    exists: boolean;
+    status?: DeploymentStatus;
+    memorySize?: bigint;
+    cycles?: bigint;
+}>;
+//# sourceMappingURL=deployer.d.ts.map