agentvault 1.0.1 → 1.0.2

package/dist/src/wallet/wallet-storage.js

@@ -0,0 +1,274 @@
+/**
+ * Wallet Storage Module
+ *
+ * Manages encrypted wallet persistence in ~/.agentvault/wallets/
+ * Provides per-agent wallet isolation and encryption.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { serializeWallet, deserializeWallet, validateCborData, } from './cbor-serializer.js';
+/**
+ * Get base directory for wallet storage
+ *
+ * @param options - Storage options
+ * @returns Wallet base directory
+ */
+export function getWalletBaseDir(options = {}) {
+    const baseDir = options.baseDir || path.join(os.homedir(), '.agentvault', 'wallets');
+    return baseDir;
+}
+/**
+ * Get agent-specific wallet directory
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ * @returns Agent wallet directory
+ */
+export function getAgentWalletDir(agentId, options = {}) {
+    const baseDir = getWalletBaseDir(options);
+    return path.join(baseDir, agentId);
+}
+/**
+ * Get wallet file path
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ * @returns Wallet file path
+ */
+export function getWalletFilePath(agentId, walletId, options = {}) {
+    const agentDir = getAgentWalletDir(agentId, options);
+    return path.join(agentDir, `${walletId}.wallet`);
+}
+/**
+ * Ensure wallet directories exist
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ */
+export function ensureWalletDirectories(agentId, options = {}) {
+    const agentDir = getAgentWalletDir(agentId, options);
+    if (!fs.existsSync(agentDir)) {
+        fs.mkdirSync(agentDir, { recursive: true });
+    }
+}
+/**
+ * Save wallet to encrypted storage
+ *
+ * @param wallet - Wallet data to save
+ * @param options - Storage options
+ */
+export function saveWallet(wallet, options = {}) {
+    // Ensure directories exist
+    ensureWalletDirectories(wallet.agentId, options);
+    // Serialize wallet to CBOR
+    const serialized = serializeWallet(wallet);
+    // Get wallet file path
+    const walletPath = getWalletFilePath(wallet.agentId, wallet.id, options);
+    // Write wallet file
+    fs.writeFileSync(walletPath, Buffer.from(serialized));
+}
+/**
+ * Load wallet from storage
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ * @returns Loaded wallet data or null if not found
+ */
+export function loadWallet(agentId, walletId, options = {}) {
+    const walletPath = getWalletFilePath(agentId, walletId, options);
+    // Check if wallet file exists
+    if (!fs.existsSync(walletPath)) {
+        return null;
+    }
+    // Read wallet file
+    const data = fs.readFileSync(walletPath);
+    // Validate CBOR data
+    if (!validateCborData(new Uint8Array(data))) {
+        throw new Error(`Invalid wallet data: ${walletId}`);
+    }
+    // Deserialize wallet
+    const wallet = deserializeWallet(new Uint8Array(data));
+    return wallet;
+}
+/**
+ * Delete wallet from storage
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ */
+export function deleteWallet(agentId, walletId, options = {}) {
+    const walletPath = getWalletFilePath(agentId, walletId, options);
+    // Check if wallet file exists
+    if (fs.existsSync(walletPath)) {
+        fs.unlinkSync(walletPath);
+    }
+}
+/**
+ * List all wallets for an agent
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ * @returns Array of wallet IDs
+ */
+export function listWallets(agentId, options = {}) {
+    const agentDir = getAgentWalletDir(agentId, options);
+    // Check if agent directory exists
+    if (!fs.existsSync(agentDir)) {
+        return [];
+    }
+    // Read all wallet files
+    const files = fs.readdirSync(agentDir);
+    // Filter and extract wallet IDs
+    const walletIds = files
+        .filter((file) => file.endsWith('.wallet'))
+        .map((file) => file.replace('.wallet', ''));
+    return walletIds;
+}
+/**
+ * List all agents with wallets
+ *
+ * @param options - Storage options
+ * @returns Array of agent IDs
+ */
+export function listAgents(options = {}) {
+    const baseDir = getWalletBaseDir(options);
+    // Check if base directory exists
+    if (!fs.existsSync(baseDir)) {
+        return [];
+    }
+    // Read all agent directories
+    const agents = fs.readdirSync(baseDir);
+    // Filter out non-directories
+    const agentIds = agents.filter((agent) => {
+        const agentPath = path.join(baseDir, agent);
+        return fs.statSync(agentPath).isDirectory();
+    });
+    return agentIds;
+}
+/**
+ * Check if wallet exists
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ * @returns True if wallet exists
+ */
+export function walletExists(agentId, walletId, options = {}) {
+    const walletPath = getWalletFilePath(agentId, walletId, options);
+    return fs.existsSync(walletPath);
+}
+/**
+ * Get wallet file stats
+ *
+ * @param agentId - Agent ID
+ * @param walletId - Wallet ID
+ * @param options - Storage options
+ * @returns Wallet file stats or null if not found
+ */
+export function getWalletStats(agentId, walletId, options = {}) {
+    const walletPath = getWalletFilePath(agentId, walletId, options);
+    if (!fs.existsSync(walletPath)) {
+        return null;
+    }
+    const stats = fs.statSync(walletPath);
+    return {
+        size: stats.size,
+        modified: stats.mtime,
+        created: stats.birthtime,
+    };
+}
+/**
+ * Backup all wallets for an agent
+ *
+ * @param agentId - Agent ID
+ * @param backupPath - Path to save backup
+ * @param options - Storage options
+ */
+export function backupWallets(agentId, backupPath, options = {}) {
+    const agentDir = getAgentWalletDir(agentId, options);
+    if (!fs.existsSync(agentDir)) {
+        throw new Error(`No wallets found for agent: ${agentId}`);
+    }
+    // Create backup directory
+    const backupDir = path.join(backupPath, agentId);
+    if (!fs.existsSync(backupDir)) {
+        fs.mkdirSync(backupDir, { recursive: true });
+    }
+    // Copy all wallet files
+    const files = fs.readdirSync(agentDir);
+    for (const file of files) {
+        const srcPath = path.join(agentDir, file);
+        const destPath = path.join(backupDir, file);
+        fs.copyFileSync(srcPath, destPath);
+    }
+}
+/**
+ * Restore wallets from backup
+ *
+ * @param agentId - Agent ID
+ * @param backupPath - Path to backup directory
+ * @param options - Storage options
+ */
+export function restoreWallets(agentId, backupPath, options = {}) {
+    const agentDir = getAgentWalletDir(agentId, options);
+    if (!fs.existsSync(backupPath)) {
+        throw new Error(`Backup directory not found: ${backupPath}`);
+    }
+    // Ensure agent directory exists
+    ensureWalletDirectories(agentId, options);
+    // Copy all wallet files from backup
+    const files = fs.readdirSync(backupPath);
+    for (const file of files) {
+        if (file.endsWith('.wallet')) {
+            const srcPath = path.join(backupPath, file);
+            const destPath = path.join(agentDir, file);
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Clear all wallets for an agent
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ */
+export function clearWallets(agentId, options = {}) {
+    const agentDir = getAgentWalletDir(agentId, options);
+    if (!fs.existsSync(agentDir)) {
+        return; // Nothing to clear
+    }
+    // Delete all wallet files
+    const files = fs.readdirSync(agentDir);
+    for (const file of files) {
+        const filePath = path.join(agentDir, file);
+        fs.unlinkSync(filePath);
+    }
+}
+/**
+ * Get total storage size for an agent
+ *
+ * @param agentId - Agent ID
+ * @param options - Storage options
+ * @returns Total size in bytes
+ */
+export function getWalletStorageSize(agentId, options = {}) {
+    const agentDir = getAgentWalletDir(agentId, options);
+    if (!fs.existsSync(agentDir)) {
+        return 0;
+    }
+    let totalSize = 0;
+    const files = fs.readdirSync(agentDir);
+    for (const file of files) {
+        const filePath = path.join(agentDir, file);
+        const stats = fs.statSync(filePath);
+        if (stats.isFile() && file.endsWith('.wallet')) {
+            totalSize += stats.size;
+        }
+    }
+    return totalSize;
+}
+//# sourceMappingURL=wallet-storage.js.map

package/macos-wallet-app/AgentVaultWallet/App/AgentVaultWalletApp.swift

@@ -0,0 +1,54 @@
+import SwiftUI
+
+@main
+struct AgentVaultWalletApp: App {
+    @StateObject private var walletStore = WalletStore()
+    @StateObject private var appState = AppState()
+
+    var body: some Scene {
+        WindowGroup {
+            MainView()
+                .environmentObject(walletStore)
+                .environmentObject(appState)
+                .frame(minWidth: 900, minHeight: 600)
+                .onAppear {
+                    walletStore.loadWallets()
+                    appState.checkEnvironment()
+                }
+        }
+        .windowStyle(.titleBar)
+        .windowToolbarStyle(.unified(showsTitle: true))
+        .defaultSize(width: 1100, height: 720)
+        .commands {
+            CommandGroup(replacing: .newItem) {
+                Button("New Wallet...") {
+                    appState.activeSheet = .createWallet
+                }
+                .keyboardShortcut("n", modifiers: .command)
+
+                Button("Import Wallet...") {
+                    appState.activeSheet = .importWallet
+                }
+                .keyboardShortcut("i", modifiers: .command)
+
+                Divider()
+
+                Button("Backup All Wallets...") {
+                    appState.activeSheet = .backup
+                }
+                .keyboardShortcut("b", modifiers: [.command, .shift])
+
+                Button("Restore from Backup...") {
+                    appState.activeSheet = .restore
+                }
+                .keyboardShortcut("r", modifiers: [.command, .shift])
+            }
+        }
+
+        Settings {
+            SettingsView()
+                .environmentObject(walletStore)
+                .environmentObject(appState)
+        }
+    }
+}

package/macos-wallet-app/AgentVaultWallet/Models/AppState.swift

@@ -0,0 +1,102 @@
+import SwiftUI
+import Combine
+
+/// Sheets/modals the app can present
+enum ActiveSheet: Identifiable {
+    case createWallet
+    case importWallet
+    case backup
+    case restore
+    case walletDetail(Wallet)
+    case mnemonicReveal(UUID)
+
+    var id: String {
+        switch self {
+        case .createWallet: return "create"
+        case .importWallet: return "import"
+        case .backup: return "backup"
+        case .restore: return "restore"
+        case .walletDetail(let w): return "detail-\(w.id)"
+        case .mnemonicReveal(let id): return "mnemonic-\(id)"
+        }
+    }
+}
+
+/// Navigation destinations for the sidebar
+enum NavigationDestination: Hashable {
+    case dashboard
+    case walletList
+    case walletDetail(UUID)
+    case backup
+    case settings
+}
+
+/// Alert types
+struct AlertInfo: Identifiable {
+    let id = UUID()
+    let title: String
+    let message: String
+    let style: AlertStyle
+
+    enum AlertStyle {
+        case info, success, warning, error
+    }
+}
+
+/// Environment health check results
+struct EnvironmentStatus {
+    var nodeInstalled: Bool = false
+    var nodeVersion: String?
+    var npmInstalled: Bool = false
+    var agentVaultInstalled: Bool = false
+    var agentVaultVersion: String?
+    var isReady: Bool { nodeInstalled && npmInstalled }
+}
+
+/// Global application state
+@MainActor
+final class AppState: ObservableObject {
+    @Published var activeSheet: ActiveSheet?
+    @Published var selectedDestination: NavigationDestination = .dashboard
+    @Published var alert: AlertInfo?
+    @Published var isFirstLaunch: Bool = true
+    @Published var environment = EnvironmentStatus()
+    @Published var isCheckingEnvironment: Bool = false
+
+    @AppStorage("hasCompletedOnboarding") var hasCompletedOnboarding: Bool = false
+    @AppStorage("agentVaultCLIPath") var cliPath: String = ""
+    @AppStorage("autoRefreshBalances") var autoRefreshBalances: Bool = true
+    @AppStorage("defaultChain") var defaultChain: String = Chain.ethereum.rawValue
+
+    private let cliBridge = CLIBridge()
+
+    init() {
+        isFirstLaunch = !hasCompletedOnboarding
+    }
+
+    func completeOnboarding() {
+        hasCompletedOnboarding = true
+        isFirstLaunch = false
+    }
+
+    func checkEnvironment() {
+        isCheckingEnvironment = true
+        Task {
+            let env = await cliBridge.checkEnvironment()
+            self.environment = env
+            self.isCheckingEnvironment = false
+        }
+    }
+
+    func showAlert(title: String, message: String, style: AlertInfo.AlertStyle = .info) {
+        alert = AlertInfo(title: title, message: message, style: style)
+    }
+
+    func showError(_ message: String) {
+        showAlert(title: "Error", message: message, style: .error)
+    }
+
+    func showSuccess(_ message: String) {
+        showAlert(title: "Success", message: message, style: .success)
+    }
+}

package/macos-wallet-app/AgentVaultWallet/Models/Chain.swift

@@ -0,0 +1,121 @@
+import SwiftUI
+
+/// Supported blockchain networks
+enum Chain: String, CaseIterable, Identifiable, Codable {
+    case icp = "ICP"
+    case ethereum = "ETH"
+    case arweave = "AR"
+
+    var id: String { rawValue }
+
+    var displayName: String {
+        switch self {
+        case .icp: return "Internet Computer"
+        case .ethereum: return "Ethereum"
+        case .arweave: return "Arweave"
+        }
+    }
+
+    var symbol: String { rawValue }
+
+    var iconName: String {
+        switch self {
+        case .icp: return "infinity"
+        case .ethereum: return "diamond.fill"
+        case .arweave: return "archivebox.fill"
+        }
+    }
+
+    var color: Color {
+        switch self {
+        case .icp: return Color(red: 0.24, green: 0.07, blue: 0.53)
+        case .ethereum: return Color(red: 0.39, green: 0.46, blue: 0.84)
+        case .arweave: return Color(red: 0.13, green: 0.13, blue: 0.13)
+        }
+    }
+
+    var gradientColors: [Color] {
+        switch self {
+        case .icp:
+            return [Color(red: 0.24, green: 0.07, blue: 0.53), Color(red: 0.58, green: 0.0, blue: 0.83)]
+        case .ethereum:
+            return [Color(red: 0.39, green: 0.46, blue: 0.84), Color(red: 0.25, green: 0.32, blue: 0.71)]
+        case .arweave:
+            return [Color(red: 0.13, green: 0.13, blue: 0.13), Color(red: 0.33, green: 0.33, blue: 0.33)]
+        }
+    }
+
+    var derivationPath: String {
+        switch self {
+        case .icp: return "m/44'/223'/0'/0/0"
+        case .ethereum: return "m/44'/60'/0'/0/0"
+        case .arweave: return "" // Arweave uses RSA JWK, not HD derivation
+        }
+    }
+
+    /// What import methods are available for this chain
+    var supportedImportMethods: [ImportMethod] {
+        switch self {
+        case .icp: return [.mnemonic, .privateKey, .pemFile]
+        case .ethereum: return [.mnemonic, .privateKey, .keystoreJSON]
+        case .arweave: return [.jwkFile, .mnemonic]
+        }
+    }
+
+    var addressPrefix: String {
+        switch self {
+        case .icp: return "Principal"
+        case .ethereum: return "0x"
+        case .arweave: return "ar://"
+        }
+    }
+
+    var explorerURLBase: String? {
+        switch self {
+        case .icp: return "https://dashboard.internetcomputer.org/account/"
+        case .ethereum: return "https://etherscan.io/address/"
+        case .arweave: return "https://viewblock.io/arweave/address/"
+        }
+    }
+}
+
+/// Methods for importing an existing wallet
+enum ImportMethod: String, CaseIterable, Identifiable {
+    case mnemonic = "mnemonic"
+    case privateKey = "private_key"
+    case pemFile = "pem_file"
+    case keystoreJSON = "keystore_json"
+    case jwkFile = "jwk_file"
+
+    var id: String { rawValue }
+
+    var displayName: String {
+        switch self {
+        case .mnemonic: return "Recovery Phrase"
+        case .privateKey: return "Private Key"
+        case .pemFile: return "PEM File"
+        case .keystoreJSON: return "Keystore JSON"
+        case .jwkFile: return "JWK Key File"
+        }
+    }
+
+    var description: String {
+        switch self {
+        case .mnemonic: return "Enter your 12 or 24-word recovery phrase"
+        case .privateKey: return "Paste your hex-encoded private key"
+        case .pemFile: return "Select a PEM identity file"
+        case .keystoreJSON: return "Select an Ethereum keystore JSON file"
+        case .jwkFile: return "Select an Arweave JWK wallet file"
+        }
+    }
+
+    var iconName: String {
+        switch self {
+        case .mnemonic: return "text.word.spacing"
+        case .privateKey: return "key.fill"
+        case .pemFile: return "doc.text.fill"
+        case .keystoreJSON: return "lock.doc.fill"
+        case .jwkFile: return "doc.badge.gearshape.fill"
+        }
+    }
+}

package/macos-wallet-app/AgentVaultWallet/Models/Wallet.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+/// Represents a single wallet managed by the application
+struct Wallet: Identifiable, Codable, Hashable {
+    let id: UUID
+    var name: String
+    let chain: Chain
+    let address: String
+    let createdAt: Date
+    var lastAccessedAt: Date
+
+    /// Whether this wallet was imported (vs. created fresh)
+    let isImported: Bool
+
+    /// Optional balance cached from last refresh
+    var cachedBalance: String?
+    var balanceLastUpdated: Date?
+
+    /// Derivation path used (empty for Arweave JWK)
+    let derivationPath: String
+
+    /// Whether the mnemonic is stored in Keychain
+    let hasMnemonicBackup: Bool
+
+    init(
+        id: UUID = UUID(),
+        name: String,
+        chain: Chain,
+        address: String,
+        isImported: Bool = false,
+        derivationPath: String = "",
+        hasMnemonicBackup: Bool = false
+    ) {
+        self.id = id
+        self.name = name
+        self.chain = chain
+        self.address = address
+        self.createdAt = Date()
+        self.lastAccessedAt = Date()
+        self.isImported = isImported
+        self.derivationPath = derivationPath
+        self.hasMnemonicBackup = hasMnemonicBackup
+    }
+
+    /// Truncated address for display
+    var shortAddress: String {
+        if address.count > 20 {
+            let prefix = String(address.prefix(10))
+            let suffix = String(address.suffix(8))
+            return "\(prefix)...\(suffix)"
+        }
+        return address
+    }
+
+    /// Explorer URL for this wallet's address
+    var explorerURL: URL? {
+        guard let base = chain.explorerURLBase else { return nil }
+        return URL(string: base + address)
+    }
+
+    /// Formatted balance string with symbol
+    var displayBalance: String {
+        guard let balance = cachedBalance else { return "—" }
+        return "\(balance) \(chain.symbol)"
+    }
+}
+
+/// Represents the result of a wallet generation or import
+struct WalletCreationResult {
+    let wallet: Wallet
+    let mnemonic: String?      // 12/24-word phrase (nil for JWK imports)
+    let privateKeyHex: String? // Hex-encoded private key
+    let jwkData: Data?         // Arweave JWK JSON (only for Arweave)
+}
+
+/// Wallet metadata stored in the backup manifest
+struct WalletBackupEntry: Codable, Identifiable {
+    let id: UUID
+    let name: String
+    let chain: Chain
+    let address: String
+    let createdAt: Date
+    let derivationPath: String
+    let hasMnemonicBackup: Bool
+}
+
+/// Full backup file structure
+struct WalletBackup: Codable {
+    let version: Int
+    let createdAt: Date
+    let appVersion: String
+    let wallets: [WalletBackupEntry]
+    let encryptedPayload: Data // AES-256-GCM encrypted wallet secrets
+    let salt: Data             // PBKDF2 salt
+    let iv: Data               // AES IV/nonce
+
+    static let currentVersion = 1
+}

package/macos-wallet-app/AgentVaultWallet/Resources/AgentVaultWallet.entitlements

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <!-- Hardened runtime -->
+    <key>com.apple.security.app-sandbox</key>
+    <false/>
+
+    <!-- Keychain access for storing wallet secrets -->
+    <key>com.apple.security.keychain-access-groups</key>
+    <array>
+        <string>$(AppIdentifierPrefix)com.agentvault.wallet</string>
+    </array>
+
+    <!-- Network access for balance checks and chain RPC calls -->
+    <key>com.apple.security.network.client</key>
+    <true/>
+
+    <!-- File access for backups and JWK/PEM imports -->
+    <key>com.apple.security.files.user-selected.read-write</key>
+    <true/>
+
+    <!-- Allow spawning Node.js / CLI processes -->
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+</dict>
+</plist>