agentvault 1.0.0

package/dist/cli/commands/package.js

@@ -0,0 +1,188 @@
+/**
+ * Package command - Compile agent to WASM for deployment
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import * as path from 'node:path';
+import { packageAgent, getPackageSummary } from '../../src/packaging/index.js';
+/**
+ * Format file size for display
+ */
+function formatSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+/**
+ * Display package preview (dry-run)
+ */
+export function displayPreview(sourcePath) {
+    const { config, validation } = getPackageSummary(sourcePath);
+    console.log(chalk.bold('\nPackage Preview\n'));
+    console.log(chalk.cyan('Agent Configuration:'));
+    console.log(`  Name:        ${chalk.bold(config.name)}`);
+    console.log(`  Type:        ${chalk.bold(config.type)}`);
+    console.log(`  Source:      ${config.sourcePath}`);
+    console.log(`  Entry Point: ${config.entryPoint ?? chalk.yellow('not detected')}`);
+    console.log(`  Version:     ${config.version ?? chalk.yellow('not specified')}`);
+    // Display agent settings for Clawdbot agents if available
+    if (config.type === 'clawdbot' && 'settings' in config) {
+        const settings = config.settings;
+        console.log();
+        console.log(chalk.cyan('Agent Settings:'));
+        if (settings.model) {
+            console.log(`  Model: ${chalk.bold(settings.model)}`);
+        }
+        if (settings.temperature !== undefined) {
+            console.log(`  Temperature: ${chalk.bold(String(settings.temperature))}`);
+        }
+        if (settings.maxTokens !== undefined) {
+            console.log(`  Max Tokens: ${chalk.bold(String(settings.maxTokens))}`);
+        }
+    }
+    console.log();
+    if (validation.warnings.length > 0) {
+        console.log(chalk.yellow('Warnings:'));
+        for (const warning of validation.warnings) {
+            console.log(chalk.yellow(`  ⚠ ${warning}`));
+        }
+        console.log();
+    }
+    if (validation.errors.length > 0) {
+        console.log(chalk.red('Errors:'));
+        for (const error of validation.errors) {
+            console.log(chalk.red(`  ✖ ${error.message}`));
+        }
+        console.log();
+    }
+    console.log(chalk.cyan('Output Files:'));
+    console.log(`  ${config.name}.wasm      - Compiled WebAssembly module`);
+    console.log(`  ${config.name}.wat       - WebAssembly text format`);
+    console.log(`  ${config.name}.state.json - Initial agent state`);
+}
+/**
+ * Display package result
+ */
+export function displayResult(result) {
+    console.log();
+    console.log(chalk.green('✓'), 'Agent packaged successfully!');
+    console.log();
+    console.log(chalk.cyan('Compilation:'));
+    console.log(`  Target:    ${chalk.bold(result.target.toUpperCase())}`);
+    console.log(`  Duration:  ${result.duration ? `${result.duration}ms` : 'N/A'}`);
+    console.log();
+    console.log(chalk.cyan('Output Files:'));
+    console.log(`  WASM:     ${result.wasmPath} (${formatSize(result.wasmSize)})`);
+    console.log(`  WAT:      ${result.watPath}`);
+    console.log(`  State:    ${result.statePath}`);
+    if (result.jsBundlePath) {
+        console.log(`  JS Bundle: ${result.jsBundlePath}`);
+    }
+    if (result.sourceMapPath) {
+        console.log(`  Source Map: ${result.sourceMapPath}`);
+    }
+    if (result.manifestPath) {
+        console.log(`  Manifest:  ${result.manifestPath}`);
+    }
+    // Display optimization results if available
+    if (result.originalWasmSize !== undefined) {
+        console.log(chalk.cyan('Optimization:'));
+        console.log(`  Original: ${formatSize(result.originalWasmSize)}`);
+        console.log(`  Optimized: ${formatSize(result.wasmSize)}`);
+        if (result.optimizationReductionPercent !== undefined) {
+            console.log(`  Reduction: ${result.optimizationReductionPercent}%`);
+        }
+        if (result.candidValidationPassed !== undefined) {
+            const status = result.candidValidationPassed
+                ? chalk.green('passed')
+                : chalk.red('failed');
+            console.log(`  Candid Validation: ${status}`);
+        }
+        if (result.optimizationWarnings && result.optimizationWarnings.length > 0) {
+            for (const warning of result.optimizationWarnings) {
+                console.log(chalk.yellow(`  Warning: ${warning}`));
+            }
+        }
+        console.log();
+    }
+    console.log(chalk.cyan('Next steps:'));
+    console.log('  1. Review the generated files');
+    console.log('  2. Run', chalk.bold('soulrecall deploy'), 'to upload to ICP');
+}
+/**
+ * Execute the package command
+ */
+export async function executePackage(sourcePath, options) {
+    // Handle dry-run mode
+    if (options.dryRun) {
+        displayPreview(sourcePath);
+        return null;
+    }
+    const spinner = ora('Packaging agent...').start();
+    try {
+        // Prepare package options
+        const packageOptions = {
+            sourcePath,
+            outputPath: options.output ? path.resolve(options.output) : undefined,
+            force: options.force,
+            skipValidation: options.skipValidation,
+            target: options.target,
+            debug: options.debug,
+            optimize: options.optimize,
+            icWasmOptimize: options.icWasmOptimize,
+            icWasmShrink: options.icWasmShrink,
+            candidInterface: options.validate,
+            memoryLimit: options.memoryLimit,
+            computeQuota: options.computeQuota,
+        };
+        // Execute packaging
+        const result = await packageAgent(packageOptions);
+        spinner.succeed(`Agent '${result.config.name}' packaged successfully!`);
+        displayResult(result);
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Packaging failed: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Create the package command
+ */
+export function packageCommand() {
+    const command = new Command('package');
+    command
+        .description('Compile agent to WASM for deployment to ICP')
+        .argument('[source]', 'path to agent source directory', '.')
+        .option('-o, --output <path>', 'output directory for compiled files')
+        .option('-f, --force', 'overwrite existing output files')
+        .option('--skip-validation', 'skip validation checks')
+        .option('--dry-run', 'show what would be packaged without executing')
+        .option('-t, --target <target>', 'compilation target (wasmedge|motoko|pure-wasm)', 'wasmedge')
+        .option('--debug', 'enable debugging features (source maps, verbose output)')
+        .option('--optimize <level>', 'optimization level (0-3)', '2')
+        .option('--ic-wasm-optimize', 'optimize WASM with ic-wasm (requires ic-wasm)')
+        .option('--ic-wasm-shrink', 'shrink WASM with ic-wasm (requires ic-wasm)')
+        .option('--validate <did-file>', 'validate WASM endpoints against Candid .did file')
+        .option('--memory-limit <limit>', 'set canister memory limit (e.g. 4GiB)')
+        .option('--compute-quota <quota>', 'set canister compute quota')
+        .action(async (source, options) => {
+        console.log(chalk.bold('\n📦 SoulRecall Package\n'));
+        try {
+            await executePackage(source, options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red(`\nError: ${message}`));
+            process.exit(1);
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=package.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Profile CLI command
+ *
+ * Provides command for profiling canister performance
+ */
+import { Command } from 'commander';
+export declare const profileCmd: Command;
+//# sourceMappingURL=profile.d.ts.map

package/dist/cli/commands/profile.js

@@ -0,0 +1,76 @@
+/**
+ * Profile CLI command
+ *
+ * Provides command for profiling canister performance
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'node:fs';
+export const profileCmd = new Command('profile');
+profileCmd
+    .description('[Experimental] Profile canister performance')
+    .argument('<canister-id>', 'Canister ID')
+    .option('-d, --duration <seconds>', 'Profile duration in seconds', '30')
+    .option('--export <file>', 'Export profile data to file')
+    .option('--format <format>', 'Export format (json, flamegraph)', 'json')
+    .action(async (canisterId, options) => {
+    console.log(chalk.yellow('[Experimental] This feature is under active development and may change.'));
+    const duration = parseInt(options.duration, 10);
+    const spinner = ora(`Profiling ${canisterId} for ${duration}s...`).start();
+    try {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        const mockResult = {
+            samples: 100,
+            duration,
+            methodStats: new Map([
+                ['query', { count: 60, totalDuration: 1200, avgDuration: 20, maxDuration: 45 }],
+                ['update', { count: 30, totalDuration: 1800, avgDuration: 60, maxDuration: 120 }],
+                ['heartbeat', { count: 10, totalDuration: 100, avgDuration: 10, maxDuration: 15 }],
+            ]),
+            memorySnapshots: [1024, 1152, 1088, 1200, 1184],
+        };
+        spinner.succeed(chalk.green('Profiling completed'));
+        console.log(chalk.bold('\nProfile Results:'));
+        console.log(chalk.gray(`  Duration: ${mockResult.duration}s`));
+        console.log(chalk.gray(`  Samples: ${mockResult.samples}`));
+        console.log();
+        console.log(chalk.bold('Method Statistics:'));
+        for (const [method, stats] of mockResult.methodStats) {
+            console.log(`\n  ${chalk.cyan(method)}:`);
+            console.log(chalk.gray(`    Calls: ${stats.count}`));
+            console.log(chalk.gray(`    Total: ${stats.totalDuration}ms`));
+            console.log(chalk.gray(`    Avg: ${stats.avgDuration.toFixed(2)}ms`));
+            console.log(chalk.gray(`    Max: ${stats.maxDuration}ms`));
+        }
+        console.log();
+        console.log(chalk.bold('Memory Snapshots (KB):'));
+        console.log(chalk.gray(`  ${mockResult.memorySnapshots.join(' → ')}`));
+        if (options.export) {
+            const exportData = {
+                samples: mockResult.samples,
+                duration: mockResult.duration,
+                methodStats: Object.fromEntries(mockResult.methodStats),
+                memorySnapshots: mockResult.memorySnapshots,
+            };
+            const exportSpinner = ora(`Exporting to ${options.export}...`).start();
+            if (options.format === 'json') {
+                fs.writeFileSync(options.export, JSON.stringify(exportData, null, 2), 'utf8');
+            }
+            else {
+                fs.writeFileSync(options.export, 'Flamegraph export not yet implemented', 'utf8');
+            }
+            exportSpinner.succeed(chalk.green(`Profile exported to ${options.export}`));
+        }
+        console.log();
+        console.log(chalk.yellow('Profiling is in mock mode.'));
+        console.log(chalk.gray('Real profiling requires soulrecall instrument and trace collection.'));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to profile canister'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=profile.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Promote CLI command
+ *
+ * Provides commands for promoting canisters between environments
+ */
+import { Command } from 'commander';
+export declare const promoteCmd: Command;
+//# sourceMappingURL=promote.d.ts.map

package/dist/cli/commands/promote.js

@@ -0,0 +1,89 @@
+/**
+ * Promote CLI command
+ *
+ * Provides commands for promoting canisters between environments
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { promoteCanister, getLatestDeployment, getAllDeployments } from '../../src/deployment/promotion.js';
+export const promoteCmd = new Command('promote');
+promoteCmd
+    .description('Promote canisters between environments')
+    .argument('<agent-name>', 'Agent name to promote')
+    .option('-f, --from <env>', 'Source environment')
+    .option('-t, --to <env>', 'Target environment')
+    .option('--target-canister <id>', 'Target canister ID (optional)')
+    .option('--blue-green', 'Enable blue-green deployment', false)
+    .option('-w, --wasm-path <path>', 'Path to WASM file for actual deployment')
+    .option('--skip-deploy', 'Skip actual deploy, only update history')
+    .action(async (agentName, options) => {
+    if (!options.from) {
+        console.error(chalk.red('Error: --from is required'));
+        process.exit(1);
+    }
+    if (!options.to) {
+        console.error(chalk.red('Error: --to is required'));
+        process.exit(1);
+    }
+    const spinner = ora(`Promoting ${agentName} from ${options.from} to ${options.to}...`).start();
+    try {
+        const sourceDeployment = getLatestDeployment(agentName, options.from);
+        if (!sourceDeployment) {
+            spinner.fail(chalk.red(`No deployment found for ${agentName} in ${options.from}`));
+            process.exit(1);
+        }
+        console.log(chalk.gray(`\nSource deployment:`));
+        console.log(chalk.gray(`  Environment: ${sourceDeployment.environment}`));
+        console.log(chalk.gray(`  Canister ID: ${sourceDeployment.canisterId}`));
+        console.log(chalk.gray(`  WASM Hash: ${sourceDeployment.wasmHash}`));
+        console.log(chalk.gray(`  Version: ${sourceDeployment.version}`));
+        console.log(chalk.gray(`  Deployed: ${sourceDeployment.timestamp.toISOString()}`));
+        console.log();
+        const result = await promoteCanister(agentName, options.from, options.to, {
+            targetCanisterId: options.targetCanister,
+            blueGreen: options.blueGreen,
+            wasmPath: options.wasmPath,
+            skipDeploy: options.skipDeploy,
+        });
+        spinner.succeed(chalk.green(`Promoted ${agentName} from ${options.from} to ${options.to}`));
+        console.log(chalk.bold('\nNew deployment:'));
+        console.log(chalk.gray(`  Environment: ${result.environment}`));
+        console.log(chalk.gray(`  Canister ID: ${result.canisterId}`));
+        console.log(chalk.gray(`  WASM Hash: ${result.wasmHash}`));
+        console.log(chalk.gray(`  Version: ${result.version}`));
+        console.log(chalk.gray(`  Deployed: ${result.timestamp.toISOString()}`));
+        if (options.blueGreen) {
+            console.log(chalk.yellow('\nNote: Blue-green deployment enabled. You may need to manually switch traffic to the new canister.'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to promote canister'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+promoteCmd
+    .command('list')
+    .description('List deployment history for an agent')
+    .argument('<agent-name>', 'Agent name')
+    .action(async (agentName) => {
+    const deployments = getAllDeployments(agentName);
+    if (deployments.length === 0) {
+        console.log(chalk.yellow(`No deployments found for ${agentName}`));
+        return;
+    }
+    console.log(chalk.bold(`Deployment history for ${agentName}:`));
+    console.log();
+    for (const deployment of deployments) {
+        const statusColor = deployment.success ? chalk.green : chalk.red;
+        console.log(`${statusColor(deployment.success ? '✓' : '✗')} Version ${deployment.version}`);
+        console.log(chalk.gray(`  Environment: ${deployment.environment}`));
+        console.log(chalk.gray(`  Canister ID: ${deployment.canisterId}`));
+        console.log(chalk.gray(`  WASM Hash: ${deployment.wasmHash}`));
+        console.log(chalk.gray(`  Timestamp: ${deployment.timestamp.toISOString()}`));
+        console.log();
+    }
+});
+//# sourceMappingURL=promote.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * Rebuild command - Rebuild local agent from canister state
+ */
+import { Command } from 'commander';
+export interface RebuildCommandOptions {
+    output?: string;
+    force?: boolean;
+    skipCompile?: boolean;
+    target?: 'wasmedge' | 'motoko' | 'pure-wasm';
+    debug?: boolean;
+    optimize?: number;
+}
+export interface RebuildAnswers {
+    confirm: boolean;
+}
+export declare function executeRebuild(stateFile: string, options: RebuildCommandOptions): Promise<void>;
+/**
+ * Create rebuild command
+ */
+export declare function rebuildCommand(): Command;
+//# sourceMappingURL=rebuild.d.ts.map

package/dist/cli/commands/rebuild.js

@@ -0,0 +1,140 @@
+/**
+ * Rebuild command - Rebuild local agent from canister state
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { compileToWasm } from '../../src/packaging/compiler.js';
+export async function executeRebuild(stateFile, options) {
+    const resolvedPath = path.resolve(stateFile);
+    // Validate state file exists
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`State file not found: ${resolvedPath}`);
+    }
+    const spinner = ora('Reading agent state...').start();
+    let state;
+    try {
+        // Read and parse state
+        const content = fs.readFileSync(resolvedPath, 'utf-8');
+        state = JSON.parse(content);
+        spinner.succeed('Agent state loaded successfully!');
+        console.log();
+        console.log(chalk.cyan('Agent Configuration:'));
+        console.log(`  Name:        ${chalk.bold(state.config.name)}`);
+        console.log(`  Type:        ${state.config.type}`);
+        console.log(`  Source:      ${state.config.sourcePath}`);
+        console.log(`  Version:     ${state.config.version ?? 'N/A'}`);
+        console.log();
+        console.log(chalk.cyan('State Info:'));
+        console.log(`  Memories:    ${state.memories?.length || 0}`);
+        console.log(`  Tasks:       ${state.tasks?.length || 0}`);
+        console.log(`  Context:     ${Object.keys(state.context || {}).length} entries`);
+        console.log();
+        console.log(chalk.yellow('Agent tasks can be resumed'));
+        console.log('Context is preserved');
+        spinner.stop();
+    }
+    catch (error) {
+        spinner.stop();
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to parse state file: ${message}`);
+    }
+    // Check if source directory exists
+    if (!fs.existsSync(state.config.sourcePath)) {
+        console.log();
+        console.log(chalk.yellow('⚠'), 'Source directory not found:', state.config.sourcePath);
+        console.log();
+        console.log('You need to provide a source code to rebuild agent.');
+        console.log('Options:');
+        console.log('  1. Clone original repository');
+        console.log('  2. Provide a new source directory');
+        spinner.stop();
+        return;
+    }
+    // Confirm rebuild
+    if (!options.force) {
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Rebuild agent with this configuration?',
+                default: true,
+            },
+        ]);
+        if (!confirm) {
+            console.log(chalk.yellow('\nRebuild cancelled.'));
+            spinner.stop();
+            return;
+        }
+    }
+    // Skip compilation if requested
+    if (options.skipCompile) {
+        console.log();
+        console.log(chalk.green('✓'), 'Rebuild skipped compilation step.');
+        console.log();
+        console.log(chalk.cyan('Agent state ready for use'));
+        console.log('Memories can be restored');
+        spinner.stop();
+        return;
+    }
+    // Compile agent to WASM
+    const compileSpinner = ora('Compiling agent to WASM...').start();
+    try {
+        const compileOptions = {
+            sourcePath: state.config.sourcePath,
+            target: options.target ?? 'wasmedge',
+            debug: options.debug ?? false,
+            optimize: options.optimize ?? 2,
+        };
+        const result = await compileToWasm(state.config, compileOptions, path.dirname(resolvedPath));
+        compileSpinner.succeed(`Agent compiled successfully!`);
+        console.log();
+        console.log(chalk.cyan('Output Files:'));
+        console.log(`  WASM:  ${result.wasmPath}`);
+        console.log(`  WAT:   ${result.watPath}`);
+        console.log(`  State: ${result.statePath}`);
+        console.log();
+        console.log(chalk.green('✓'), 'Agent rebuilt successfully!');
+        console.log();
+        console.log(chalk.cyan('Next steps:'));
+        console.log('  1. Test rebuilt agent locally');
+        console.log('  2. Deploy with:', chalk.bold('soulrecall deploy'));
+    }
+    catch (error) {
+        compileSpinner.fail('Compilation failed');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Rebuild failed: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Create rebuild command
+ */
+export function rebuildCommand() {
+    const command = new Command('rebuild');
+    command
+        .description('Rebuild local agent from canister state')
+        .argument('<state-file>', 'agent state file (JSON)')
+        .option('-o, --output <path>', 'output directory for rebuilt agent')
+        .option('-f, --force', 'skip confirmation prompts')
+        .option('--skip-compile', 'skip WASM compilation')
+        .option('-t, --target <target>', 'compilation target (wasmedge|motoko|pure-wasm)', 'wasmedge')
+        .option('--debug', 'enable debugging features')
+        .option('--optimize <level>', 'optimization level (0-3)', '2')
+        .action(async (stateFile, options) => {
+        console.log(chalk.bold('\n🔧 SoulRecall Rebuild\n'));
+        try {
+            await executeRebuild(stateFile, options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red(`\nError: ${message}`));
+            process.exit(1);
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=rebuild.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Rollback CLI command
+ *
+ * Provides commands for rolling back canisters to previous versions
+ */
+import { Command } from 'commander';
+export declare const rollbackCmd: Command;
+//# sourceMappingURL=rollback.d.ts.map

package/dist/cli/commands/rollback.js

@@ -0,0 +1,120 @@
+/**
+ * Rollback CLI command
+ *
+ * Provides commands for rolling back canisters to previous versions
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getDeploymentForRollback, getDeploymentsByTimeRange, getAllDeployments, } from '../../src/deployment/promotion.js';
+import { deploy } from '../../src/icp/icpcli.js';
+export const rollbackCmd = new Command('rollback');
+rollbackCmd
+    .description('Rollback canisters to previous versions')
+    .argument('<agent-name>', 'Agent name to rollback')
+    .option('-e, --env <env>', 'Environment to rollback', 'production')
+    .option('-v, --version <version>', 'Version to rollback to')
+    .option('-t, --to <timestamp>', 'Rollback to timestamp')
+    .option('--dry-run', 'Show what would be rolled back without executing', false)
+    .action(async (agentName, options) => {
+    if (!options.version && !options.to) {
+        console.error(chalk.red('Error: --version or --to is required'));
+        process.exit(1);
+    }
+    const spinner = ora(`Finding deployment to rollback...`).start();
+    try {
+        let targetDeployment;
+        if (options.version) {
+            const version = parseInt(options.version, 10);
+            targetDeployment = getDeploymentForRollback(agentName, options.env, version);
+            if (!targetDeployment) {
+                spinner.fail(chalk.red(`Version ${version} not found for ${agentName} in ${options.env}`));
+                process.exit(1);
+            }
+        }
+        else {
+            const toTimestamp = new Date(options.to);
+            const fromTimestamp = new Date(toTimestamp.getTime() - 30 * 24 * 60 * 60 * 1000);
+            const deployments = getDeploymentsByTimeRange(agentName, options.env, fromTimestamp, toTimestamp);
+            if (deployments.length === 0) {
+                spinner.fail(chalk.red(`No deployments found for ${agentName} in ${options.env} before ${options.to}`));
+                process.exit(1);
+            }
+            targetDeployment = deployments[0];
+        }
+        if (!targetDeployment) {
+            spinner.fail(chalk.red('No deployment found'));
+            process.exit(1);
+        }
+        spinner.succeed(chalk.green('Found deployment to rollback to'));
+        console.log(chalk.bold('\nTarget deployment:'));
+        console.log(chalk.gray(`  Environment: ${targetDeployment.environment}`));
+        console.log(chalk.gray(`  Canister ID: ${targetDeployment.canisterId}`));
+        console.log(chalk.gray(`  WASM Hash: ${targetDeployment.wasmHash}`));
+        console.log(chalk.gray(`  Version: ${targetDeployment.version}`));
+        console.log(chalk.gray(`  Timestamp: ${targetDeployment.timestamp.toISOString()}`));
+        console.log();
+        if (options.dryRun) {
+            console.log(chalk.yellow('Dry run: No changes will be made'));
+            console.log(chalk.gray(`To perform the rollback, run without --dry-run`));
+            return;
+        }
+        const confirmSpinner = ora(`Rolling back ${agentName} to version ${targetDeployment.version}...`).start();
+        const result = await deploy({
+            environment: options.env,
+            projectRoot: process.cwd(),
+        });
+        if (!result.success) {
+            confirmSpinner.fail(chalk.red('Rollback failed'));
+            console.error(chalk.red(result.stderr));
+            process.exit(1);
+        }
+        confirmSpinner.succeed(chalk.green(`Rolled back ${agentName} to version ${targetDeployment.version}`));
+        console.log(result.stdout);
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to rollback'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+rollbackCmd
+    .command('list')
+    .description('List available rollback versions')
+    .argument('<agent-name>', 'Agent name')
+    .option('-e, --env <env>', 'Environment to list versions for', 'production')
+    .action(async (agentName, options) => {
+    const deployments = getAllDeployments(agentName);
+    const envDeployments = deployments
+        .filter((d) => d.environment === options.env && d.success)
+        .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    if (envDeployments.length === 0) {
+        console.log(chalk.yellow(`No deployments found for ${agentName} in ${options.env}`));
+        return;
+    }
+    console.log(chalk.bold(`Available rollback versions for ${agentName} (${options.env}):`));
+    console.log();
+    for (const deployment of envDeployments) {
+        const relativeTime = formatRelativeTime(deployment.timestamp);
+        console.log(`${chalk.gray('→')} Version ${deployment.version} ${chalk.gray(`(${relativeTime})`)}`);
+        console.log(chalk.gray(`    Canister: ${deployment.canisterId}`));
+        console.log(chalk.gray(`    WASM: ${deployment.wasmHash.substring(0, 16)}...`));
+        console.log();
+    }
+});
+function formatRelativeTime(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffMins < 1)
+        return 'just now';
+    if (diffMins < 60)
+        return `${diffMins}m ago`;
+    if (diffHours < 24)
+        return `${diffHours}h ago`;
+    return `${diffDays}d ago`;
+}
+//# sourceMappingURL=rollback.js.map