agentvault 1.0.1 → 1.0.2

package/dist/src/archival/archive-manager.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Archive Manager
+ *
+ * Manages archiving of agent data to Arweave.
+ * Handles metadata tracking, batch uploads, and retrieval.
+ */
+export interface ArchiveMetadata {
+    id: string;
+    agentName: string;
+    agentVersion: string;
+    transactionId?: string;
+    timestamp: Date;
+    sizeBytes: number;
+    checksum: string;
+    tags: Record<string, string>;
+    status: 'pending' | 'uploading' | 'confirmed' | 'failed';
+    blockHeight?: number;
+}
+export interface ArchiveOptions {
+    includeConfig?: boolean;
+    includeLogs?: boolean;
+    includeMetrics?: boolean;
+    tags?: Record<string, string>;
+}
+export interface ArchiveResult {
+    success: boolean;
+    archiveId?: string;
+    transactionId?: string;
+    error?: string;
+}
+/**
+ * Archive agent data to local storage (for later upload)
+ */
+export declare function prepareArchive(agentName: string, agentVersion: string, data: Record<string, any>, options?: ArchiveOptions): ArchiveResult;
+/**
+ * Mark archive as uploading
+ */
+export declare function markArchiveUploading(archiveId: string): boolean;
+/**
+ * Update archive with transaction ID
+ */
+export declare function updateArchiveTransaction(archiveId: string, transactionId: string): boolean;
+/**
+ * Mark archive as confirmed
+ */
+export declare function confirmArchive(archiveId: string, blockHeight?: number): boolean;
+/**
+ * Mark archive as failed
+ */
+export declare function failArchive(archiveId: string, error?: string): boolean;
+/**
+ * Get archive metadata by ID
+ */
+export declare function getArchive(archiveId: string): ArchiveMetadata | null;
+/**
+ * List all archives for an agent
+ */
+export declare function listArchives(agentName?: string): ArchiveMetadata[];
+/**
+ * List pending archives (ready for upload)
+ */
+export declare function listPendingArchives(): ArchiveMetadata[];
+/**
+ * Get archive data by ID
+ */
+export declare function getArchiveData(archiveId: string): Record<string, any> | null;
+/**
+ * Delete archive (local storage only, does not affect Arweave)
+ */
+export declare function deleteArchive(archiveId: string): boolean;
+/**
+ * Get archive statistics
+ */
+export declare function getArchiveStats(agentName?: string): {
+    total: number;
+    confirmed: number;
+    pending: number;
+    failed: number;
+    totalBytes: number;
+};
+/**
+ * Verify archive checksum
+ */
+export declare function verifyArchive(archiveId: string): boolean;
+//# sourceMappingURL=archive-manager.d.ts.map

package/dist/src/archival/archive-manager.js

@@ -0,0 +1,294 @@
+/**
+ * Archive Manager
+ *
+ * Manages archiving of agent data to Arweave.
+ * Handles metadata tracking, batch uploads, and retrieval.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { parse, stringify } from 'yaml';
+const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
+const ARCHIVES_DIR = path.join(AGENTVAULT_DIR, 'archives');
+const ARCHIVE_INDEX_PATH = path.join(ARCHIVES_DIR, 'index.yaml');
+function ensureArchivesDir() {
+    if (!fs.existsSync(AGENTVAULT_DIR)) {
+        fs.mkdirSync(AGENTVAULT_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(ARCHIVES_DIR)) {
+        fs.mkdirSync(ARCHIVES_DIR, { recursive: true });
+    }
+}
+function getIndex() {
+    if (!fs.existsSync(ARCHIVE_INDEX_PATH)) {
+        return [];
+    }
+    try {
+        const content = fs.readFileSync(ARCHIVE_INDEX_PATH, 'utf8');
+        const parsed = parse(content);
+        if (Array.isArray(parsed)) {
+            return parsed.map((item) => ({
+                ...item,
+                timestamp: new Date(item.timestamp),
+            }));
+        }
+        return [];
+    }
+    catch (error) {
+        console.error('Failed to load archive index:', error);
+        return [];
+    }
+}
+function saveIndex(index) {
+    ensureArchivesDir();
+    fs.writeFileSync(ARCHIVE_INDEX_PATH, stringify(index), 'utf8');
+}
+function generateChecksum(data) {
+    return crypto.createHash('sha256').update(data).digest('hex');
+}
+function generateArchiveId() {
+    return `archive-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+}
+/**
+ * Archive agent data to local storage (for later upload)
+ */
+export function prepareArchive(agentName, agentVersion, data, options = {}) {
+    try {
+        ensureArchivesDir();
+        const archiveId = generateArchiveId();
+        const timestamp = new Date();
+        const dataStr = JSON.stringify(data);
+        const checksum = generateChecksum(dataStr);
+        const metadata = {
+            id: archiveId,
+            agentName,
+            agentVersion,
+            timestamp,
+            sizeBytes: Buffer.byteLength(dataStr),
+            checksum,
+            tags: {
+                'agent-name': agentName,
+                'agent-version': agentVersion,
+                'content-type': 'application/json',
+                ...options.tags,
+            },
+            status: 'pending',
+        };
+        const archivePath = path.join(ARCHIVES_DIR, `${archiveId}.json`);
+        fs.writeFileSync(archivePath, dataStr, 'utf8');
+        const index = getIndex();
+        index.push(metadata);
+        saveIndex(index);
+        return {
+            success: true,
+            archiveId,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Mark archive as uploading
+ */
+export function markArchiveUploading(archiveId) {
+    try {
+        const index = getIndex();
+        const archive = index.find((a) => a.id === archiveId);
+        if (!archive) {
+            return false;
+        }
+        archive.status = 'uploading';
+        saveIndex(index);
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to mark archive as uploading:', error);
+        return false;
+    }
+}
+/**
+ * Update archive with transaction ID
+ */
+export function updateArchiveTransaction(archiveId, transactionId) {
+    try {
+        const index = getIndex();
+        const archive = index.find((a) => a.id === archiveId);
+        if (!archive) {
+            return false;
+        }
+        archive.transactionId = transactionId;
+        archive.status = 'pending';
+        saveIndex(index);
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to update archive transaction:', error);
+        return false;
+    }
+}
+/**
+ * Mark archive as confirmed
+ */
+export function confirmArchive(archiveId, blockHeight) {
+    try {
+        const index = getIndex();
+        const archive = index.find((a) => a.id === archiveId);
+        if (!archive) {
+            return false;
+        }
+        archive.status = 'confirmed';
+        if (blockHeight) {
+            archive.blockHeight = blockHeight;
+        }
+        saveIndex(index);
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to confirm archive:', error);
+        return false;
+    }
+}
+/**
+ * Mark archive as failed
+ */
+export function failArchive(archiveId, error) {
+    try {
+        const index = getIndex();
+        const archive = index.find((a) => a.id === archiveId);
+        if (!archive) {
+            return false;
+        }
+        archive.status = 'failed';
+        if (error) {
+            archive.tags['error'] = error;
+        }
+        saveIndex(index);
+        return true;
+    }
+    catch (err) {
+        console.error('Failed to mark archive as failed:', err);
+        return false;
+    }
+}
+/**
+ * Get archive metadata by ID
+ */
+export function getArchive(archiveId) {
+    try {
+        const index = getIndex();
+        return index.find((a) => a.id === archiveId) || null;
+    }
+    catch (error) {
+        console.error('Failed to get archive:', error);
+        return null;
+    }
+}
+/**
+ * List all archives for an agent
+ */
+export function listArchives(agentName) {
+    try {
+        const index = getIndex();
+        if (agentName) {
+            return index.filter((a) => a.agentName === agentName);
+        }
+        return index;
+    }
+    catch (error) {
+        console.error('Failed to list archives:', error);
+        return [];
+    }
+}
+/**
+ * List pending archives (ready for upload)
+ */
+export function listPendingArchives() {
+    try {
+        const index = getIndex();
+        return index.filter((a) => a.status === 'pending');
+    }
+    catch (error) {
+        console.error('Failed to list pending archives:', error);
+        return [];
+    }
+}
+/**
+ * Get archive data by ID
+ */
+export function getArchiveData(archiveId) {
+    try {
+        const archivePath = path.join(ARCHIVES_DIR, `${archiveId}.json`);
+        if (!fs.existsSync(archivePath)) {
+            return null;
+        }
+        const content = fs.readFileSync(archivePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.error('Failed to get archive data:', error);
+        return null;
+    }
+}
+/**
+ * Delete archive (local storage only, does not affect Arweave)
+ */
+export function deleteArchive(archiveId) {
+    try {
+        const index = getIndex();
+        const archiveIndex = index.findIndex((a) => a.id === archiveId);
+        if (archiveIndex === -1) {
+            return false;
+        }
+        const archivePath = path.join(ARCHIVES_DIR, `${archiveId}.json`);
+        if (fs.existsSync(archivePath)) {
+            fs.unlinkSync(archivePath);
+        }
+        index.splice(archiveIndex, 1);
+        saveIndex(index);
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to delete archive:', error);
+        return false;
+    }
+}
+/**
+ * Get archive statistics
+ */
+export function getArchiveStats(agentName) {
+    const archives = listArchives(agentName);
+    return {
+        total: archives.length,
+        confirmed: archives.filter((a) => a.status === 'confirmed').length,
+        pending: archives.filter((a) => a.status === 'pending').length,
+        failed: archives.filter((a) => a.status === 'failed').length,
+        totalBytes: archives.reduce((sum, a) => sum + a.sizeBytes, 0),
+    };
+}
+/**
+ * Verify archive checksum
+ */
+export function verifyArchive(archiveId) {
+    try {
+        const metadata = getArchive(archiveId);
+        if (!metadata) {
+            return false;
+        }
+        const data = getArchiveData(archiveId);
+        if (!data) {
+            return false;
+        }
+        const actualChecksum = generateChecksum(JSON.stringify(data));
+        return actualChecksum === metadata.checksum;
+    }
+    catch (error) {
+        console.error('Failed to verify archive:', error);
+        return false;
+    }
+}
+//# sourceMappingURL=archive-manager.js.map

package/dist/src/archival/arweave-client.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Arweave Client
+ *
+ * Handles interaction with Arweave network for permanent data archival.
+ * Supports uploading data, retrieving transactions, and checking status.
+ */
+export interface ArweaveConfig {
+    host?: string;
+    port?: number;
+    protocol?: 'http' | 'https';
+    timeout?: number;
+    logging?: boolean;
+}
+export interface UploadOptions {
+    tags?: Record<string, string>;
+    fee?: number;
+}
+export interface ArchiveTransaction {
+    id: string;
+    owner: string;
+    tags: Record<string, string>;
+    size: number;
+    timestamp: Date;
+    block?: {
+        height: number;
+        indep_hash: string;
+    };
+}
+export interface UploadResult {
+    success: boolean;
+    transactionId?: string;
+    error?: string;
+}
+export type JWKInterface = Record<string, any>;
+export declare class ArweaveClient {
+    private config;
+    private client;
+    constructor(config?: ArweaveConfig);
+    /**
+     * Initialize Arweave client (lazy loading)
+     */
+    private getClient;
+    /**
+     * Dynamically import arweave (optional dependency)
+     */
+    private importArweave;
+    /**
+     * Upload data to Arweave
+     */
+    uploadData(data: string | Buffer, jwk: JWKInterface, options?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Upload JSON data to Arweave
+     */
+    uploadJSON<T>(jsonData: T, jwk: JWKInterface, options?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Get transaction data by ID
+     */
+    getTransactionData(transactionId: string): Promise<string | null>;
+    /**
+     * Get transaction status
+     */
+    getTransactionStatus(transactionId: string): Promise<'pending' | 'confirmed' | 'not_found' | 'error'>;
+    /**
+     * Get transaction info
+     */
+    getTransaction(transactionId: string): Promise<ArchiveTransaction | null>;
+    /**
+     * Get wallet balance in AR
+     */
+    getWalletBalance(address: string): Promise<string>;
+    /**
+     * Estimate upload cost in AR
+     */
+    estimateUploadCost(dataSizeBytes: number): Promise<string>;
+    /**
+     * Generate a new Arweave wallet
+     */
+    generateWallet(): Promise<JWKInterface>;
+    /**
+     * Get wallet address from JWK
+     */
+    getAddressFromJWK(jwk: JWKInterface): Promise<string>;
+    /**
+     * Create Arweave instance
+     */
+    getClientInstance(): Promise<any>;
+}
+//# sourceMappingURL=arweave-client.d.ts.map

package/dist/src/archival/arweave-client.js

@@ -0,0 +1,223 @@
+/**
+ * Arweave Client
+ *
+ * Handles interaction with Arweave network for permanent data archival.
+ * Supports uploading data, retrieving transactions, and checking status.
+ */
+export class ArweaveClient {
+    config;
+    client = null;
+    constructor(config = {}) {
+        this.config = {
+            host: config.host || 'arweave.net',
+            port: config.port || 443,
+            protocol: config.protocol || 'https',
+            timeout: config.timeout || 20000,
+            logging: config.logging || false,
+        };
+    }
+    /**
+     * Initialize Arweave client (lazy loading)
+     */
+    async getClient() {
+        if (!this.client) {
+            try {
+                const Arweave = await this.importArweave();
+                this.client = new Arweave({
+                    host: this.config.host,
+                    port: this.config.port,
+                    protocol: this.config.protocol,
+                    timeout: this.config.timeout,
+                    logging: this.config.logging,
+                });
+            }
+            catch (_error) {
+                throw new Error('arweave is required for ArweaveClient. Install with: npm install arweave');
+            }
+        }
+        return this.client;
+    }
+    /**
+     * Dynamically import arweave (optional dependency)
+     */
+    async importArweave() {
+        try {
+            const dynamicImport = new Function('modulePath', 'return import(modulePath)');
+            const arweaveModule = await dynamicImport('arweave');
+            return arweaveModule.default;
+        }
+        catch (_error) {
+            throw new Error('arweave is required for ArweaveClient. Install with: npm install arweave');
+        }
+    }
+    /**
+     * Upload data to Arweave
+     */
+    async uploadData(data, jwk, options = {}) {
+        try {
+            const client = await this.getClient();
+            const transaction = await client.createTransaction({
+                data: typeof data === 'string' ? data : data.toString('base64'),
+            }, jwk);
+            if (options.tags) {
+                for (const [key, value] of Object.entries(options.tags)) {
+                    transaction.addTag(key, value);
+                }
+            }
+            await client.transactions.sign(transaction, jwk);
+            const response = await client.transactions.post(transaction);
+            if (response.status === 200 || response.status === 202) {
+                return {
+                    success: true,
+                    transactionId: transaction.id,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    error: `Upload failed with status ${response.status}`,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Upload JSON data to Arweave
+     */
+    async uploadJSON(jsonData, jwk, options = {}) {
+        return this.uploadData(JSON.stringify(jsonData), jwk, {
+            ...options,
+            tags: {
+                'Content-Type': 'application/json',
+                ...(options.tags || {}),
+            },
+        });
+    }
+    /**
+     * Get transaction data by ID
+     */
+    async getTransactionData(transactionId) {
+        try {
+            const client = await this.getClient();
+            const data = await client.transactions.getData(transactionId, {
+                decode: true,
+            });
+            return data.toString();
+        }
+        catch (error) {
+            console.error(`Failed to fetch transaction ${transactionId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Get transaction status
+     */
+    async getTransactionStatus(transactionId) {
+        try {
+            const client = await this.getClient();
+            const status = await client.transactions.getStatus(transactionId);
+            if (!status) {
+                return 'not_found';
+            }
+            if (status.confirmed && status.confirmed.number_of_confirmations > 0) {
+                return 'confirmed';
+            }
+            return 'pending';
+        }
+        catch (error) {
+            console.error(`Failed to check status for ${transactionId}:`, error);
+            return 'error';
+        }
+    }
+    /**
+     * Get transaction info
+     */
+    async getTransaction(transactionId) {
+        try {
+            const client = await this.getClient();
+            const transaction = await client.transactions.get(transactionId);
+            const tags = {};
+            transaction.get('tags').forEach((tag) => {
+                const name = tag.get('name', { decode: true, string: true });
+                const value = tag.get('value', { decode: true, string: true });
+                if (name && value) {
+                    tags[name] = value;
+                }
+            });
+            const block = transaction.get('block');
+            let blockInfo;
+            if (block) {
+                blockInfo = {
+                    height: block.get('height'),
+                    indep_hash: block.get('indep_hash'),
+                };
+            }
+            return {
+                id: transaction.id,
+                owner: transaction.owner,
+                tags,
+                size: parseInt(transaction.data_size, 10),
+                timestamp: new Date(parseInt(transaction.last_tx, 10) * 1000),
+                block: blockInfo,
+            };
+        }
+        catch (error) {
+            console.error(`Failed to fetch transaction ${transactionId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Get wallet balance in AR
+     */
+    async getWalletBalance(address) {
+        try {
+            const client = await this.getClient();
+            const balance = await client.wallets.getBalance(address);
+            return client.ar.winstonToAr(balance);
+        }
+        catch (error) {
+            console.error(`Failed to fetch balance for ${address}:`, error);
+            return '0';
+        }
+    }
+    /**
+     * Estimate upload cost in AR
+     */
+    async estimateUploadCost(dataSizeBytes) {
+        try {
+            const client = await this.getClient();
+            const price = await client.transactions.getPrice(dataSizeBytes);
+            return client.ar.winstonToAr(price);
+        }
+        catch (error) {
+            console.error('Failed to estimate cost:', error);
+            return '0';
+        }
+    }
+    /**
+     * Generate a new Arweave wallet
+     */
+    async generateWallet() {
+        const client = await this.getClient();
+        return client.wallets.generate();
+    }
+    /**
+     * Get wallet address from JWK
+     */
+    async getAddressFromJWK(jwk) {
+        const client = await this.getClient();
+        return client.wallets.jwkToAddress(jwk);
+    }
+    /**
+     * Create Arweave instance
+     */
+    async getClientInstance() {
+        return this.getClient();
+    }
+}
+//# sourceMappingURL=arweave-client.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Archival Module
+ *
+ * Exports archival functionality.
+ */
+export * from './arweave-client.js';
+export * from './archive-manager.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -3,6 +3,6 @@
  *
  * Exports archival functionality.
  */
-
 export * from './arweave-client.js';
 export * from './archive-manager.js';
+//# sourceMappingURL=index.js.map