agentvault 1.0.1 → 1.0.2

package/dist/src/backup/backup.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Backup System
+ *
+ * Portable JSON format backup with embedded manifest and checksums
+ * Stores backups in ~/.agentvault/backups/
+ * CLE-101: Enhanced to include real canister state
+ */
+import type { AgentConfig } from '../packaging/types.js';
+/**
+ * Canister state captured in backup
+ */
+export interface CanisterState {
+    canisterId: string;
+    status: 'running' | 'stopped' | 'stopping';
+    memorySize?: bigint;
+    cycles?: bigint;
+    moduleHash?: string;
+    fetchedAt: string;
+    tasks?: unknown[];
+    memory?: unknown;
+    context?: unknown;
+}
+export interface BackupManifest {
+    version: string;
+    agentName: string;
+    timestamp: Date;
+    created: Date;
+    agentConfig?: AgentConfig;
+    canisterId?: string;
+    canisterState?: CanisterState;
+    checksums: Record<string, string>;
+    size: number;
+    components: string[];
+}
+export interface BackupOptions {
+    agentName: string;
+    outputPath?: string;
+    includeConfig?: boolean;
+    canisterId?: string;
+    includeCanisterState?: boolean;
+}
+export interface ImportOptions {
+    inputPath: string;
+    targetAgentName?: string;
+    overwrite?: boolean;
+}
+export interface BackupResult {
+    success: boolean;
+    path?: string;
+    error?: string;
+    sizeBytes?: number;
+    manifest?: BackupManifest;
+}
+export interface ImportResult {
+    success: boolean;
+    agentName?: string;
+    error?: string;
+    components: string[];
+    warnings: string[];
+}
+export declare function exportBackup(options: BackupOptions): Promise<BackupResult>;
+export declare function previewBackup(inputPath: string): Promise<BackupManifest | null>;
+export declare function importBackup(options: ImportOptions): Promise<ImportResult>;
+export declare function listBackups(agentName: string): Promise<BackupManifest[]>;
+export declare function deleteBackup(filePath: string): Promise<boolean>;
+export declare function formatBackupSize(bytes: number): string;
+//# sourceMappingURL=backup.d.ts.map

package/dist/src/backup/backup.js

@@ -0,0 +1,231 @@
+/**
+ * Backup System
+ *
+ * Portable JSON format backup with embedded manifest and checksums
+ * Stores backups in ~/.agentvault/backups/
+ * CLE-101: Enhanced to include real canister state
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
+const BACKUPS_DIR = path.join(AGENTVAULT_DIR, 'backups');
+function ensureBackupsDir() {
+    if (!fs.existsSync(AGENTVAULT_DIR)) {
+        fs.mkdirSync(AGENTVAULT_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(BACKUPS_DIR)) {
+        fs.mkdirSync(BACKUPS_DIR, { recursive: true });
+    }
+}
+/**
+ * Fetch canister state for backup
+ */
+async function fetchCanisterState(canisterId) {
+    try {
+        const { createICPClient } = await import('../deployment/icpClient.js');
+        const client = createICPClient({ network: 'local' });
+        const status = await client.getCanisterStatus(canisterId);
+        const statusMap = {
+            running: 'running',
+            stopped: 'stopped',
+            stopping: 'stopping',
+            pending: 'stopped',
+        };
+        const state = {
+            canisterId,
+            status: statusMap[status.status] || 'stopped',
+            memorySize: status.memorySize,
+            cycles: status.cycles,
+            fetchedAt: new Date().toISOString(),
+        };
+        try {
+            const tasksResult = await client.callAgentMethod(canisterId, 'getTasks', []);
+            if (tasksResult) {
+                state.tasks = tasksResult;
+            }
+        }
+        catch {
+            // Tasks not available
+        }
+        try {
+            const memoryResult = await client.callAgentMethod(canisterId, 'getMemory', []);
+            if (memoryResult) {
+                state.memory = memoryResult;
+            }
+        }
+        catch {
+            // Memory not available
+        }
+        try {
+            const contextResult = await client.callAgentMethod(canisterId, 'getContext', []);
+            if (contextResult) {
+                state.context = contextResult;
+            }
+        }
+        catch {
+            // Context not available
+        }
+        return state;
+    }
+    catch (error) {
+        console.warn('Failed to fetch canister state:', error);
+        return null;
+    }
+}
+export async function exportBackup(options) {
+    try {
+        ensureBackupsDir();
+        const { agentName, outputPath, includeConfig = true, canisterId, includeCanisterState = true } = options;
+        const timestamp = new Date();
+        const created = new Date();
+        const filename = `${agentName}-${timestamp.toISOString().replace(/[:.]/g, '-')}.json`;
+        const filePath = outputPath || path.join(BACKUPS_DIR, filename);
+        const components = [];
+        if (includeConfig) {
+            components.push('config');
+        }
+        const manifest = {
+            version: '1.1',
+            agentName,
+            timestamp,
+            created,
+            checksums: {},
+            size: 0,
+            components,
+        };
+        if (includeConfig) {
+            manifest.canisterId = canisterId || agentName;
+        }
+        if (includeCanisterState && canisterId) {
+            const canisterState = await fetchCanisterState(canisterId);
+            if (canisterState) {
+                manifest.canisterState = canisterState;
+                manifest.canisterId = canisterId;
+                components.push('canister-state');
+            }
+        }
+        const content = JSON.stringify(manifest, null, 2);
+        const checksum = crypto.createHash('sha256').update(content).digest('hex');
+        manifest.checksums[filename] = checksum;
+        fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2), 'utf8');
+        const stats = fs.statSync(filePath);
+        manifest.size = stats.size;
+        return {
+            success: true,
+            path: filePath,
+            sizeBytes: stats.size,
+            manifest,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export async function previewBackup(inputPath) {
+    try {
+        if (!fs.existsSync(inputPath)) {
+            return null;
+        }
+        const content = fs.readFileSync(inputPath, 'utf8');
+        const manifest = JSON.parse(content);
+        return manifest;
+    }
+    catch (error) {
+        console.error('Failed to preview backup:', error);
+        return null;
+    }
+}
+export async function importBackup(options) {
+    try {
+        const { inputPath, targetAgentName, overwrite } = options;
+        if (!fs.existsSync(inputPath)) {
+            return {
+                success: false,
+                agentName: undefined,
+                components: [],
+                warnings: [],
+                error: `Backup file not found: ${inputPath}`,
+            };
+        }
+        const manifest = await previewBackup(inputPath);
+        if (!manifest) {
+            return {
+                success: false,
+                agentName: undefined,
+                components: [],
+                warnings: [],
+                error: 'Invalid backup file',
+            };
+        }
+        const targetName = targetAgentName || manifest.agentName;
+        const warnings = [];
+        if (!overwrite) {
+            warnings.push('Using dry-run mode; no changes will be made');
+        }
+        return {
+            success: true,
+            agentName: targetName,
+            components: manifest.components,
+            warnings,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            agentName: undefined,
+            components: [],
+            warnings: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export async function listBackups(agentName) {
+    ensureBackupsDir();
+    const backups = [];
+    if (!fs.existsSync(BACKUPS_DIR)) {
+        return backups;
+    }
+    const files = fs.readdirSync(BACKUPS_DIR);
+    for (const file of files) {
+        if (file.startsWith(agentName) && file.endsWith('.json')) {
+            const filePath = path.join(BACKUPS_DIR, file);
+            try {
+                const manifest = await previewBackup(filePath);
+                if (manifest && manifest.agentName === agentName) {
+                    backups.push(manifest);
+                }
+            }
+            catch (error) {
+                console.error(`Failed to read backup ${file}:`, error);
+            }
+        }
+    }
+    backups.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    return backups;
+}
+export async function deleteBackup(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        console.error('Failed to delete backup:', error);
+        return false;
+    }
+}
+export function formatBackupSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+//# sourceMappingURL=backup.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * Backup Module
+ *
+ * Exports backup functionality.
+ */
+export * from './backup.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -3,5 +3,5 @@
  *
  * Exports backup functionality.
  */
-
 export * from './backup.js';
+//# sourceMappingURL=index.js.map

package/dist/src/cloud-storage/cloud-sync.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Cloud Sync
+ *
+ * Archive and restore AgentVault data to/from a cloud-synced
+ * local directory. Creates a self-contained folder with a JSON
+ * manifest so any cloud provider can sync it as plain files.
+ *
+ * No blockchain, no crypto, no API keys — just files.
+ */
+import type { CloudArchiveOptions, CloudArchiveResult, CloudRestoreResult, DiscoveredArchive } from './types.js';
+/**
+ * Return the default AgentVault data directory.
+ */
+export declare function getDefaultVaultDir(): string;
+/**
+ * Archive AgentVault data to a cloud-synced directory.
+ *
+ * Creates a timestamped folder inside the cloud backup dir
+ * containing a copy of the selected vault data plus a manifest.
+ *
+ * @param providerBasePath - Root path of the cloud provider sync directory
+ * @param options - What to include in the archive
+ * @param subdirectory - Subdirectory name inside provider (default: AgentVault-Backups)
+ * @param vaultDir - Path to the AgentVault data directory (default: ~/.agentvault)
+ */
+export declare function archiveToCloud(providerBasePath: string, options: CloudArchiveOptions, subdirectory?: string, vaultDir?: string): CloudArchiveResult;
+/**
+ * List available archives in a cloud backup directory.
+ */
+export declare function listCloudArchives(providerBasePath: string, subdirectory?: string): DiscoveredArchive[];
+/**
+ * Restore AgentVault data from a cloud archive.
+ *
+ * Copies files from the archive back into the vault directory,
+ * verifying checksums along the way.
+ *
+ * @param archivePath - Path to the archive directory
+ * @param overwrite - Whether to overwrite existing files
+ * @param vaultDir - Path to the AgentVault data directory (default: ~/.agentvault)
+ */
+export declare function restoreFromCloud(archivePath: string, overwrite?: boolean, vaultDir?: string): CloudRestoreResult;
+/**
+ * Verify integrity of a cloud archive by checking all file checksums.
+ */
+export declare function verifyCloudArchive(archivePath: string): {
+    valid: boolean;
+    errors: string[];
+};
+//# sourceMappingURL=cloud-sync.d.ts.map