agentvault 1.0.0

package/dist/cli/commands/approve.js

@@ -0,0 +1,232 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createApprovalRequest, signApprovalRequest, rejectApprovalRequest, listApprovalRequests, listPendingApprovals, deleteApprovalRequest, isApproved, getApprovalSummary, cleanupExpiredRequests, } from '../../src/security/index.js';
+const approveCmd = new Command('approve');
+approveCmd
+    .description('[Experimental] Manage multi-signature approval workflows')
+    .action(async () => {
+    console.log(chalk.yellow('[Experimental] This feature is under active development and may change.'));
+    console.log(chalk.yellow('Please specify a subcommand: create, list, sign, reject, delete, or cleanup'));
+    console.log(chalk.gray(`\nExamples:
+  ${chalk.cyan('soulrecall approve create deploy <agent-name> "Description"')}${chalk.gray('  Create approval request')}
+  ${chalk.cyan('soulrecall approve list')}${chalk.gray('                     List all requests')}
+  ${chalk.cyan('soulrecall approve sign <request-id>')}${chalk.gray('             Sign a request')}
+  ${chalk.cyan('soulrecall approve reject <request-id>')}${chalk.gray('          Reject a request')}
+  ${chalk.cyan('soulrecall approve pending <signer>')}${chalk.gray('          Show pending requests')}`));
+});
+approveCmd
+    .command('create')
+    .description('Create a new approval request')
+    .argument('<type>', 'Request type: deploy, upgrade, transfer, config_change, rollback')
+    .argument('<agent-name>', 'Agent name')
+    .argument('<description>', 'Description of the change')
+    .option('--proposed-by <name>', 'Proposer name', 'admin')
+    .option('--policy <policy>', 'Approval policy: all, majority, quorum', 'majority')
+    .option('--required <number>', 'Number of required approvals')
+    .option('--timeout <ms>', 'Approval timeout in milliseconds', '86400000')
+    .option('--signers <count>', 'Number of allowed signers', '3')
+    .action(async (type, agentName, description, options) => {
+    const spinner = ora(`Creating approval request...`).start();
+    try {
+        const config = {
+            policy: options.policy,
+            requiredApprovals: options.required ? parseInt(options.required, 10) : undefined,
+            approvalTimeoutMs: parseInt(options.timeout, 10),
+            allowedSigners: Array.from({ length: parseInt(options.signers, 10) }, (_, i) => `signer${i + 1}`),
+        };
+        const request = createApprovalRequest(type, agentName, description, options.proposedBy, config);
+        spinner.succeed(chalk.green(`Approval request created: ${request.id}`));
+        console.log(chalk.gray(`Type: ${request.type}`));
+        console.log(chalk.gray(`Policy: ${request.policy}`));
+        console.log(chalk.gray(`Required approvals: ${request.requiredApprovals}`));
+        console.log(chalk.gray(`Expires: ${request.expiresAt?.toLocaleString()}`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to create approval request'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+approveCmd
+    .command('list')
+    .description('List approval requests')
+    .option('--agent <name>', 'Filter by agent name')
+    .option('--status <status>', 'Filter by status: pending, approved, rejected, expired')
+    .action(async (options) => {
+    const spinner = ora('Loading approval requests...').start();
+    try {
+        const requests = listApprovalRequests(options.agent, options.status);
+        spinner.succeed(chalk.green(`Found ${requests.length} request(s)`));
+        if (requests.length === 0) {
+            console.log(chalk.gray('No approval requests found'));
+            return;
+        }
+        for (const req of requests) {
+            const statusColor = {
+                pending: chalk.yellow,
+                approved: chalk.green,
+                rejected: chalk.red,
+                expired: chalk.gray,
+            }[req.status] || chalk.gray;
+            const progress = `${req.approvals.length}/${req.requiredApprovals}`;
+            console.log(`\n${chalk.bold(req.id)}`);
+            console.log(`  Type: ${req.type}`);
+            console.log(`  Agent: ${req.agentName}`);
+            console.log(`  Status: ${statusColor(req.status)} ${progress}`);
+            console.log(`  Proposed by: ${req.proposedBy}`);
+            console.log(`  Description: ${req.description}`);
+            if (req.approvals.length > 0) {
+                console.log('  Signatures:');
+                for (const sig of req.approvals) {
+                    console.log(`    - ${sig.signer} (${sig.timestamp.toLocaleString()})`);
+                    if (sig.comment) {
+                        console.log(`      ${chalk.gray(sig.comment)}`);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to list approval requests'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+approveCmd
+    .command('sign')
+    .description('Sign an approval request')
+    .argument('<request-id>', 'Request ID to sign')
+    .argument('<signer>', 'Signer name')
+    .option('--comment <text>', 'Comment on signature')
+    .action(async (requestId, signer, options) => {
+    const spinner = ora(`Signing request ${requestId}...`).start();
+    try {
+        const success = signApprovalRequest(requestId, signer, options.comment);
+        if (success) {
+            const approved = isApproved(requestId);
+            spinner.succeed(chalk.green(`Request signed by ${signer}`));
+            if (approved) {
+                console.log(chalk.green('\n✓ Request is now approved!'));
+            }
+            else {
+                const summary = getApprovalSummary(requestId);
+                if (summary) {
+                    console.log(chalk.gray(`Approvals: ${summary.approved}/${summary.required}`));
+                }
+            }
+        }
+        else {
+            spinner.fail(chalk.red('Failed to sign request'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to sign request'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+approveCmd
+    .command('reject')
+    .description('Reject an approval request')
+    .argument('<request-id>', 'Request ID to reject')
+    .argument('<signer>', 'Signer name')
+    .option('--reason <text>', 'Rejection reason')
+    .action(async (requestId, signer, options) => {
+    const spinner = ora(`Rejecting request ${requestId}...`).start();
+    try {
+        const success = rejectApprovalRequest(requestId, signer, options.reason);
+        if (success) {
+            spinner.succeed(chalk.green(`Request rejected by ${signer}`));
+        }
+        else {
+            spinner.fail(chalk.red('Failed to reject request'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to reject request'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+approveCmd
+    .command('pending')
+    .description('List pending approvals for a signer')
+    .argument('<signer>', 'Signer name')
+    .action(async (signer) => {
+    const spinner = ora(`Loading pending approvals for ${signer}...`).start();
+    try {
+        const requests = listPendingApprovals(signer);
+        spinner.succeed(chalk.green(`Found ${requests.length} pending request(s)`));
+        if (requests.length === 0) {
+            console.log(chalk.gray('No pending requests'));
+            return;
+        }
+        for (const req of requests) {
+            console.log(`\n${chalk.bold(req.id)}`);
+            console.log(`  Type: ${req.type}`);
+            console.log(`  Agent: ${req.agentName}`);
+            console.log(`  Description: ${req.description}`);
+            console.log(`  Required: ${req.requiredApprovals}`);
+            console.log(`  Current: ${req.approvals.length}`);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to list pending approvals'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+approveCmd
+    .command('delete')
+    .description('Delete an approval request')
+    .argument('<request-id>', 'Request ID to delete')
+    .action(async (requestId) => {
+    const spinner = ora(`Deleting request ${requestId}...`).start();
+    try {
+        const success = deleteApprovalRequest(requestId);
+        if (success) {
+            spinner.succeed(chalk.green(`Request deleted: ${requestId}`));
+        }
+        else {
+            spinner.fail(chalk.red('Failed to delete request'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to delete request'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+approveCmd
+    .command('cleanup')
+    .description('Clean up expired requests')
+    .action(async () => {
+    const spinner = ora('Cleaning up expired requests...').start();
+    try {
+        const cleaned = cleanupExpiredRequests();
+        if (cleaned > 0) {
+            spinner.succeed(chalk.green(`Marked ${cleaned} expired request(s)`));
+        }
+        else {
+            spinner.info(chalk.gray('No expired requests to clean'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to cleanup'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+export { approveCmd };
+//# sourceMappingURL=approve.js.map

package/dist/cli/commands/archive.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+declare const archiveCmd: Command;
+export { archiveCmd };
+//# sourceMappingURL=archive.d.ts.map

package/dist/cli/commands/archive.js

@@ -0,0 +1,192 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { prepareArchive, listArchives, getArchive, deleteArchive, verifyArchive, getArchiveStats, } from '../../src/archival/index.js';
+const archiveCmd = new Command('archive');
+archiveCmd
+    .description('[Experimental] Archive agent data to permanent storage (Arweave)')
+    .action(async () => {
+    console.log(chalk.yellow('[Experimental] This feature is under active development and may change.'));
+    console.log(chalk.yellow('Please specify a subcommand: prepare, list, delete, verify, or stats'));
+    console.log(chalk.gray(`\nExamples:
+  ${chalk.cyan('soulrecall archive prepare <agent-name> <version>')}${chalk.gray('    Prepare agent data for archival')}
+  ${chalk.cyan('soulrecall archive list')}${chalk.gray('                 List all archives')}
+  ${chalk.cyan('soulrecall archive stats <agent-name>')}${chalk.gray('     Get archive statistics')}
+  ${chalk.cyan('soulrecall archive delete <archive-id>')}${chalk.gray('      Delete an archive')}
+  ${chalk.cyan('soulrecall archive verify <archive-id>')}${chalk.gray('       Verify archive integrity')}`));
+});
+archiveCmd
+    .command('prepare')
+    .description('Prepare agent data for archival (local storage)')
+    .argument('<agent-name>', 'Agent name to archive')
+    .argument('<version>', 'Agent version')
+    .option('--include-config', 'Include agent configuration', true)
+    .option('--include-logs', 'Include logs', false)
+    .option('--include-metrics', 'Include metrics', false)
+    .option('--tag <key=value>', 'Add metadata tag (can be used multiple times)', [])
+    .action(async (agentName, version, options) => {
+    const spinner = ora(`Preparing archive for ${agentName} v${version}...`).start();
+    try {
+        const data = {
+            agentName,
+            version,
+            timestamp: new Date().toISOString(),
+        };
+        if (options.includeConfig) {
+            data.config = { included: true };
+        }
+        if (options.includeLogs) {
+            data.logs = { included: true, sample: ['Sample log entry'] };
+        }
+        if (options.includeMetrics) {
+            data.metrics = { included: true };
+        }
+        const tags = {};
+        if (options.tag) {
+            for (const tag of options.tag) {
+                const parts = tag.split('=');
+                if (parts.length === 2) {
+                    tags[parts[0]] = parts[1];
+                }
+            }
+        }
+        const result = prepareArchive(agentName, version, data, {
+            includeConfig: options.includeConfig,
+            includeLogs: options.includeLogs,
+            includeMetrics: options.includeMetrics,
+            tags,
+        });
+        if (result.success && result.archiveId) {
+            spinner.succeed(chalk.green(`Archive prepared: ${result.archiveId}`));
+            console.log(chalk.gray(`Agent: ${agentName}`));
+            console.log(chalk.gray(`Version: ${version}`));
+        }
+        else {
+            spinner.fail(chalk.red('Failed to prepare archive'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to prepare archive'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+archiveCmd
+    .command('list')
+    .description('List all archives')
+    .option('--agent <name>', 'Filter by agent name')
+    .option('--status <status>', 'Filter by status (pending, uploading, confirmed, failed)')
+    .action(async (options) => {
+    const spinner = ora('Loading archives...').start();
+    try {
+        const archives = listArchives(options.agent);
+        spinner.succeed(chalk.green(`Found ${archives.length} archive(s)`));
+        if (archives.length === 0) {
+            console.log(chalk.gray('No archives found'));
+            return;
+        }
+        let filtered = archives;
+        if (options.status) {
+            filtered = archives.filter((a) => a.status === options.status);
+        }
+        for (const archive of filtered) {
+            const statusColor = {
+                pending: chalk.yellow,
+                uploading: chalk.blue,
+                confirmed: chalk.green,
+                failed: chalk.red,
+            }[archive.status] || chalk.gray;
+            console.log(`\n${chalk.bold(archive.id)}`);
+            console.log(`  Agent: ${archive.agentName}`);
+            console.log(`  Status: ${statusColor(archive.status)}`);
+            console.log(`  Size: ${archive.sizeBytes} bytes`);
+            console.log(`  Timestamp: ${archive.timestamp.toLocaleString()}`);
+            if (archive.transactionId) {
+                console.log(`  Transaction: ${archive.transactionId}`);
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to list archives'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+archiveCmd
+    .command('stats')
+    .description('Get archive statistics')
+    .option('--agent <name>', 'Filter by agent name')
+    .action(async (options) => {
+    try {
+        const stats = getArchiveStats(options.agent);
+        console.log(chalk.bold('\nArchive Statistics:'));
+        console.log(`  Total archives: ${stats.total}`);
+        console.log(`  Confirmed: ${chalk.green(stats.confirmed)}`);
+        console.log(`  Pending: ${chalk.yellow(stats.pending)}`);
+        console.log(`  Failed: ${chalk.red(stats.failed)}`);
+        console.log(`  Total size: ${(stats.totalBytes / 1024 / 1024).toFixed(2)} MB`);
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to get stats'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+archiveCmd
+    .command('delete')
+    .description('Delete an archive (local storage only)')
+    .argument('<archive-id>', 'Archive ID to delete')
+    .action(async (archiveId) => {
+    const spinner = ora(`Deleting archive ${archiveId}...`).start();
+    try {
+        const success = deleteArchive(archiveId);
+        if (success) {
+            spinner.succeed(chalk.green(`Archive deleted: ${archiveId}`));
+        }
+        else {
+            spinner.fail(chalk.red('Failed to delete archive'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to delete archive'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+archiveCmd
+    .command('verify')
+    .description('Verify archive integrity')
+    .argument('<archive-id>', 'Archive ID to verify')
+    .action(async (archiveId) => {
+    const spinner = ora(`Verifying archive ${archiveId}...`).start();
+    try {
+        const archive = getArchive(archiveId);
+        if (!archive) {
+            spinner.fail(chalk.red('Archive not found'));
+            process.exit(1);
+        }
+        const isValid = verifyArchive(archiveId);
+        if (isValid) {
+            spinner.succeed(chalk.green(`Archive verified: ${archiveId}`));
+            console.log(chalk.gray(`Checksum: ${archive.checksum}`));
+        }
+        else {
+            spinner.fail(chalk.red('Archive verification failed'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to verify archive'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+export { archiveCmd };
+//# sourceMappingURL=archive.js.map

package/dist/cli/commands/backup.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+declare const backupCmd: Command;
+export { backupCmd };
+//# sourceMappingURL=backup.d.ts.map

package/dist/cli/commands/backup.js

@@ -0,0 +1,164 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { exportBackup, previewBackup, importBackup, listBackups, deleteBackup, formatBackupSize, } from '../../src/backup/index.js';
+const backupCmd = new Command('backup');
+backupCmd
+    .description('Export and import agent backups')
+    .action(async () => {
+    console.log(chalk.yellow('Please specify a subcommand: export, import, list, delete, or preview'));
+    console.log(chalk.gray(`\nExamples:
+  ${chalk.cyan('soulrecall backup export <agent-name> --output backup.json')}${chalk.gray('    Export agent config to file')}
+  ${chalk.cyan('soulrecall backup import <file>')}${chalk.gray('           Import agent from backup file')}
+  ${chalk.cyan('soulrecall backup list')}${chalk.gray('                 List all backups')}
+  ${chalk.cyan('soulrecall backup delete <backup-path>')}${chalk.gray('      Delete a backup')}
+  ${chalk.cyan('soulrecall backup preview <backup-path>')}${chalk.gray('       Preview backup contents')}`));
+});
+backupCmd
+    .command('export')
+    .description('Export agent configuration and data to a backup file')
+    .argument('<agent-name>', 'Agent name to backup')
+    .option('-o, --output <path>', 'Output file path', './backup.json')
+    .option('-c, --canister-id <id>', 'Canister ID to include live canister state')
+    .option('--no-canister-state', 'Skip fetching canister state even if canister ID provided')
+    .action(async (agentName, options) => {
+    const outputPath = options.output.endsWith('.json') ? options.output : `${options.output}.json`;
+    const includeCanisterState = options.canisterId ? options.canisterState !== false : false;
+    const spinner = ora(`Exporting backup for ${agentName}...`).start();
+    try {
+        const result = await exportBackup({
+            agentName,
+            outputPath,
+            includeConfig: true,
+            canisterId: options.canisterId,
+            includeCanisterState,
+        });
+        if (result.success && result.path && result.manifest) {
+            spinner.succeed(chalk.green(`Backup exported to ${result.path}`));
+            const sizeBytes = result.sizeBytes || result.manifest.size;
+            console.log(chalk.gray(`Size: ${formatBackupSize(sizeBytes)}`));
+            console.log(chalk.gray(`Components: ${result.manifest.components.join(', ')}`));
+        }
+        else {
+            spinner.fail(chalk.red('Backup export failed'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Backup export failed'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+backupCmd
+    .command('import')
+    .description('Import agent configuration from a backup file')
+    .argument('<file>', 'Backup file path to import')
+    .option('--name <name>', 'New agent name (defaults to original)')
+    .option('--overwrite', 'Overwrite existing agent configuration')
+    .action(async (filePath, options) => {
+    const spinner = ora(`Importing backup from ${filePath}...`).start();
+    try {
+        const result = await importBackup({
+            inputPath: filePath,
+            targetAgentName: options.name,
+            overwrite: options.overwrite,
+        });
+        if (result.success) {
+            spinner.succeed(chalk.green(`Backup imported for ${result.agentName}`));
+            if (result.components.length > 0) {
+                console.log(chalk.gray(`Components imported: ${result.components.join(', ')}`));
+            }
+            if (result.warnings.length > 0) {
+                console.log(chalk.yellow('Warnings:'));
+                for (const warning of result.warnings) {
+                    console.log(chalk.yellow(`  - ${warning}`));
+                }
+            }
+        }
+        else {
+            spinner.fail(chalk.red('Backup import failed'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Backup import failed'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+backupCmd
+    .command('list')
+    .description('List all agent backups')
+    .option('--agent <name>', 'Filter by agent name')
+    .action(async (options) => {
+    const spinner = ora('Listing backups...').start();
+    try {
+        const backups = await listBackups(options.agent);
+        spinner.succeed(chalk.green(`Found ${backups.length} backup(s)`));
+        if (backups.length === 0) {
+            console.log(chalk.gray('No backups found'));
+            return;
+        }
+        for (const backup of backups) {
+            console.log(chalk.cyan(JSON.stringify(backup, null, 2)));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to list backups'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+backupCmd
+    .command('delete')
+    .description('Delete a backup file')
+    .argument('<backup-path>', 'Backup file path to delete')
+    .action(async (filePath) => {
+    const spinner = ora(`Deleting backup ${filePath}...`).start();
+    try {
+        const success = await deleteBackup(filePath);
+        if (success) {
+            spinner.succeed(chalk.green(`Backup deleted: ${filePath}`));
+        }
+        else {
+            spinner.fail(chalk.red('Failed to delete backup'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to delete backup'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+backupCmd
+    .command('preview')
+    .description('Preview backup contents without importing')
+    .argument('<backup-path>', 'Backup file path to preview')
+    .action(async (filePath) => {
+    const spinner = ora('Previewing backup...').start();
+    try {
+        const manifest = await previewBackup(filePath);
+        if (!manifest) {
+            spinner.fail(chalk.red('Invalid backup file'));
+            process.exit(1);
+        }
+        spinner.succeed(chalk.green('Backup manifest preview:'));
+        console.log(chalk.bold(`Agent: ${manifest.agentName}`));
+        console.log(chalk.gray(`Created: ${new Date(manifest.created).toLocaleString()}`));
+        console.log(chalk.gray(`Components: ${manifest.components.join(', ')}`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to preview backup'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+export { backupCmd };
+//# sourceMappingURL=backup.js.map

package/dist/cli/commands/cloud-backup.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+declare const cloudBackupCmd: Command;
+export { cloudBackupCmd };
+//# sourceMappingURL=cloud-backup.d.ts.map