agentvault 1.0.0

package/dist/cli/commands/cloud-backup.js

@@ -0,0 +1,221 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { detectProviders, detectAvailableProviders, createCustomProvider, resolveCloudBackupDir, archiveToCloud, listCloudArchives, restoreFromCloud, verifyCloudArchive, } from '../../src/cloud-storage/index.js';
+import { formatBackupSize } from '../../src/backup/index.js';
+const cloudBackupCmd = new Command('cloud-backup');
+cloudBackupCmd
+    .description('Archive and restore SoulRecall data using cloud storage (Google Drive, iCloud, Dropbox, etc.)')
+    .action(async () => {
+    console.log(chalk.yellow('Please specify a subcommand: providers, archive, restore, list, or verify'));
+    console.log(chalk.gray(`
+Examples:
+  ${chalk.cyan('soulrecall cloud-backup providers')}              List detected cloud providers
+  ${chalk.cyan('soulrecall cloud-backup archive --provider dropbox')}  Archive vault to Dropbox
+  ${chalk.cyan('soulrecall cloud-backup list --provider dropbox')}     List archives in Dropbox
+  ${chalk.cyan('soulrecall cloud-backup restore <archive-path>')}      Restore from archive
+  ${chalk.cyan('soulrecall cloud-backup verify <archive-path>')}       Verify archive integrity`));
+});
+// --- providers ---
+cloudBackupCmd
+    .command('providers')
+    .description('Detect available cloud storage providers on this machine')
+    .action(async () => {
+    const spinner = ora('Scanning for cloud storage providers...').start();
+    const providers = detectProviders();
+    spinner.stop();
+    const available = providers.filter((p) => p.available);
+    const unavailable = providers.filter((p) => !p.available);
+    if (available.length > 0) {
+        console.log(chalk.green(`Found ${available.length} available provider(s):\n`));
+        for (const p of available) {
+            console.log(`  ${chalk.cyan(p.label)}`);
+            console.log(`    Path: ${chalk.gray(p.path)}`);
+            console.log(`    ID:   ${chalk.gray(p.provider)}`);
+            console.log();
+        }
+    }
+    else {
+        console.log(chalk.yellow('No cloud storage providers detected. Use --path to specify a custom directory.'));
+    }
+    if (unavailable.length > 0) {
+        console.log(chalk.gray('Not detected:'));
+        for (const p of unavailable) {
+            console.log(chalk.gray(`  - ${p.label}`));
+        }
+    }
+});
+// --- archive ---
+cloudBackupCmd
+    .command('archive')
+    .description('Archive SoulRecall data to a cloud storage provider')
+    .option('-p, --provider <name>', 'Cloud provider (google-drive, icloud-drive, dropbox, onedrive)')
+    .option('--path <directory>', 'Custom directory path (overrides --provider)')
+    .option('-a, --agent <name>', 'Archive a specific agent only')
+    .option('--no-configs', 'Exclude agent configurations')
+    .option('--no-wallets', 'Exclude wallet data')
+    .option('--no-backups', 'Exclude existing backups')
+    .option('--no-networks', 'Exclude network configurations')
+    .option('--subdirectory <name>', 'Subdirectory name inside provider', 'SoulRecall-Backups')
+    .action(async (options) => {
+    // Resolve provider path
+    let providerPath;
+    let providerLabel;
+    if (options.path) {
+        const custom = createCustomProvider(options.path);
+        providerPath = custom.path;
+        providerLabel = `Custom (${options.path})`;
+    }
+    else if (options.provider) {
+        const providers = detectProviders();
+        const match = providers.find((p) => p.provider === options.provider);
+        if (!match) {
+            console.error(chalk.red(`Unknown provider "${options.provider}". Use "soulrecall cloud-backup providers" to see available options.`));
+            process.exit(1);
+            return;
+        }
+        if (!match.available) {
+            console.error(chalk.red(match.label + ' is not available on this machine. Expected path: ' + match.path));
+            process.exit(1);
+            return;
+        }
+        providerPath = match.path;
+        providerLabel = match.label;
+    }
+    else {
+        // Auto-detect: use first available
+        const available = detectAvailableProviders();
+        if (available.length === 0) {
+            console.error(chalk.red('No cloud provider detected. Use --provider or --path to specify a destination.'));
+            process.exit(1);
+            return;
+        }
+        const first = available[0];
+        providerPath = first.path;
+        providerLabel = first.label;
+        console.log(chalk.gray(`Auto-detected provider: ${providerLabel}`));
+    }
+    const spinner = ora(`Archiving to ${providerLabel}...`).start();
+    const result = archiveToCloud(providerPath, {
+        agentName: options.agent,
+        includeConfigs: options.configs !== false,
+        includeWallets: options.wallets !== false,
+        includeBackups: options.backups !== false,
+        includeNetworks: options.networks !== false,
+    }, options.subdirectory);
+    if (result.success) {
+        spinner.succeed(chalk.green(`Archive created in ${providerLabel}`));
+        console.log(chalk.gray(`  Path:  ${result.archivePath}`));
+        console.log(chalk.gray(`  Files: ${result.fileCount} (${formatBackupSize(result.totalBytes || 0)})`));
+        console.log(chalk.gray('\nYour cloud provider will sync this automatically.'));
+    }
+    else {
+        spinner.fail(chalk.red('Archive failed'));
+        console.error(chalk.red(result.error || 'Unknown error'));
+        process.exit(1);
+    }
+});
+// --- list ---
+cloudBackupCmd
+    .command('list')
+    .description('List available archives in a cloud storage directory')
+    .option('-p, --provider <name>', 'Cloud provider (google-drive, icloud-drive, dropbox, onedrive)')
+    .option('--path <directory>', 'Custom directory path')
+    .option('--subdirectory <name>', 'Subdirectory name inside provider', 'SoulRecall-Backups')
+    .action(async (options) => {
+    let providerPath;
+    if (options.path) {
+        providerPath = options.path;
+    }
+    else if (options.provider) {
+        const providers = detectProviders();
+        const match = providers.find((p) => p.provider === options.provider);
+        if (!match || !match.available) {
+            console.error(chalk.red(`Provider "${options.provider}" not available. Run "soulrecall cloud-backup providers".`));
+            process.exit(1);
+            return;
+        }
+        providerPath = match.path;
+    }
+    else {
+        const available = detectAvailableProviders();
+        if (available.length === 0) {
+            console.error(chalk.red('No cloud provider detected. Use --provider or --path.'));
+            process.exit(1);
+            return;
+        }
+        const first = available[0];
+        providerPath = first.path;
+        console.log(chalk.gray('Auto-detected provider: ' + first.label));
+    }
+    const spinner = ora('Scanning for archives...').start();
+    const archives = listCloudArchives(providerPath, options.subdirectory);
+    spinner.stop();
+    if (archives.length === 0) {
+        console.log(chalk.yellow('No archives found.'));
+        console.log(chalk.gray(`Looked in: ${resolveCloudBackupDir(providerPath, options.subdirectory)}`));
+        return;
+    }
+    console.log(chalk.green(`Found ${archives.length} archive(s):\n`));
+    for (const archive of archives) {
+        const m = archive.manifest;
+        const totalSize = m.files.reduce((s, f) => s + f.sizeBytes, 0);
+        const dateStr = new Date(m.createdAt).toLocaleString();
+        const nameStr = m.agentName || 'full-vault';
+        console.log('  ' + chalk.cyan(nameStr) + ' ' + chalk.gray('(' + dateStr + ')'));
+        console.log(chalk.gray('    Components: ' + m.components.join(', ')));
+        console.log(chalk.gray('    Files: ' + String(m.files.length) + ' (' + formatBackupSize(totalSize) + ')'));
+        console.log(chalk.gray('    Path: ' + archive.archivePath));
+        console.log();
+    }
+});
+// --- restore ---
+cloudBackupCmd
+    .command('restore')
+    .description('Restore SoulRecall data from a cloud archive')
+    .argument('<archive-path>', 'Path to the archive directory')
+    .option('--overwrite', 'Overwrite existing files', false)
+    .action(async (archivePath, options) => {
+    const spinner = ora('Restoring from archive...').start();
+    const result = restoreFromCloud(archivePath, options.overwrite);
+    if (result.success) {
+        spinner.succeed(chalk.green(`Restored ${result.restoredFiles} file(s)`));
+        if (result.components && result.components.length > 0) {
+            console.log(chalk.gray(`  Components: ${result.components.join(', ')}`));
+        }
+    }
+    else {
+        spinner.fail(chalk.red('Restore failed'));
+        console.error(chalk.red(result.error || 'Unknown error'));
+    }
+    if (result.warnings.length > 0) {
+        console.log(chalk.yellow('\nWarnings:'));
+        for (const w of result.warnings) {
+            console.log(chalk.yellow(`  - ${w}`));
+        }
+    }
+    if (!result.success) {
+        process.exit(1);
+    }
+});
+// --- verify ---
+cloudBackupCmd
+    .command('verify')
+    .description('Verify integrity of a cloud archive')
+    .argument('<archive-path>', 'Path to the archive directory')
+    .action(async (archivePath) => {
+    const spinner = ora('Verifying archive integrity...').start();
+    const result = verifyCloudArchive(archivePath);
+    if (result.valid) {
+        spinner.succeed(chalk.green('Archive integrity verified'));
+    }
+    else {
+        spinner.fail(chalk.red('Archive integrity check failed'));
+        for (const err of result.errors) {
+            console.error(chalk.red(`  - ${err}`));
+        }
+        process.exit(1);
+    }
+});
+export { cloudBackupCmd };
+//# sourceMappingURL=cloud-backup.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Cycles Command
+ *
+ * Manage ICP cycles for canisters.
+ */
+import { Command } from 'commander';
+export declare function cyclesCommand(): Command;
+//# sourceMappingURL=cycles.d.ts.map

package/dist/cli/commands/cycles.js

@@ -0,0 +1,83 @@
+/**
+ * Cycles Command
+ *
+ * Manage ICP cycles for canisters.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { checkBalance, mintCycles, transferCycles, } from '../../src/icp/cycles.js';
+export function cyclesCommand() {
+    const command = new Command('cycles');
+    command
+        .description('Manage ICP cycles')
+        .action(() => {
+        command.outputHelp();
+    })
+        .addCommand(balanceSubcommand())
+        .addCommand(mintSubcommand())
+        .addCommand(transferSubcommand());
+    return command;
+}
+async function executeBalance(options) {
+    const { canister } = options;
+    const spinner = ora(`Checking cycles balance for ${canister}...`).start();
+    try {
+        const result = await checkBalance(canister);
+        spinner.succeed(`Cycles balance checked for ${canister}`);
+        console.log();
+        console.log(chalk.cyan('Balance:'), result.stdout || 'N/A');
+    }
+    catch (error) {
+        spinner.fail(`Failed to check balance: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+async function executeMint(options) {
+    const { amount } = options;
+    const spinner = ora(`Minting ${amount} cycles...`).start();
+    try {
+        const result = await mintCycles(amount);
+        spinner.succeed(`${amount} cycles minted successfully`);
+        console.log();
+        console.log(chalk.cyan('Result:'), result.stdout || 'N/A');
+    }
+    catch (error) {
+        spinner.fail(`Failed to mint cycles: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+async function executeTransfer(options) {
+    const { amount, to } = options;
+    const spinner = ora(`Transferring ${amount} cycles to ${to}...`).start();
+    try {
+        const result = await transferCycles(amount, to);
+        spinner.succeed(`${amount} cycles transferred successfully to ${to}`);
+        console.log();
+        console.log(chalk.cyan('Result:'), result.stdout || 'N/A');
+    }
+    catch (error) {
+        spinner.fail(`Failed to transfer cycles: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+function balanceSubcommand() {
+    return new Command('balance')
+        .description('Check cycles balance of a canister')
+        .option('-c, --canister <canister-id>', 'Canister ID to check')
+        .action(executeBalance);
+}
+function mintSubcommand() {
+    return new Command('mint')
+        .description('Mint cycles to a canister')
+        .argument('<amount>', 'Amount to mint')
+        .action(executeMint);
+}
+function transferSubcommand() {
+    return new Command('transfer')
+        .description('Transfer cycles to a canister')
+        .argument('<amount>', 'Amount to transfer')
+        .argument('<to>', 'Recipient canister ID or principal')
+        .action(executeTransfer);
+}
+//# sourceMappingURL=cycles.js.map

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

@@ -0,0 +1,16 @@
+/**
+ * Decrypt command - Decrypt agent state using seed phrase
+ */
+import { Command } from 'commander';
+export interface DecryptCommandOptions {
+    output?: string;
+}
+/**
+ * Execute decrypt command
+ */
+export declare function executeDecrypt(filePath: string, options: DecryptCommandOptions): Promise<void>;
+/**
+ * Create decrypt command
+ */
+export declare function decryptCommand(): Command;
+//# sourceMappingURL=decrypt.d.ts.map

package/dist/cli/commands/decrypt.js

@@ -0,0 +1,101 @@
+/**
+ * Decrypt command - Decrypt agent state using seed phrase
+ */
+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 { decryptJSON } from '../../src/security/vetkeys.js';
+/**
+ * Execute decrypt command
+ */
+export async function executeDecrypt(filePath, options) {
+    const resolvedPath = path.resolve(filePath);
+    // Validate input file exists
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`File not found: ${resolvedPath}`);
+    }
+    // Read and parse file
+    const content = fs.readFileSync(resolvedPath, 'utf-8');
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch {
+        throw new Error('Invalid JSON format');
+    }
+    // Check if already decrypted
+    if (!('encrypted' in data && data.encrypted)) {
+        console.log(chalk.yellow('State is already decrypted.'));
+        return;
+    }
+    // Prompt for seed phrase
+    const { seedPhrase } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'seedPhrase',
+            message: 'Enter your seed phrase:',
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'Seed phrase is required';
+                }
+                const words = input.trim().split(/\s+/);
+                if (words.length !== 12 && words.length !== 24) {
+                    return 'Seed phrase must be 12 or 24 words';
+                }
+                return true;
+            },
+        },
+    ]);
+    const spinner = ora('Decrypting agent state...').start();
+    try {
+        const encrypted = data;
+        // Decrypt using VetKeys
+        const decrypted = await decryptJSON(encrypted, seedPhrase);
+        spinner.succeed('State decrypted successfully!');
+        console.log();
+        console.log(chalk.cyan('Decryption Info:'));
+        console.log(`  Algorithm:      ${encrypted.algorithm}`);
+        console.log(`  Encrypted at:   ${encrypted.encryptedAt}`);
+        // Determine output path
+        const outputPath = options.output ?? resolvedPath.replace('.json', '.decrypted.json');
+        // Write decrypted state
+        fs.writeFileSync(outputPath, JSON.stringify(decrypted, null, 2), 'utf-8');
+        console.log();
+        console.log(chalk.green('✓'), 'Decrypted state saved to:', chalk.bold(outputPath));
+        console.log();
+        console.log(chalk.cyan('Next steps:'));
+        console.log('  1. Review the decrypted state');
+        console.log('  2. Rebuild agent:', chalk.bold('soulrecall rebuild'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Decryption failed: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Create decrypt command
+ */
+export function decryptCommand() {
+    const command = new Command('decrypt');
+    command
+        .description('Decrypt agent state using seed phrase')
+        .argument('<file>', 'encrypted state file to decrypt')
+        .option('-o, --output <path>', 'output file path')
+        .action(async (file, options) => {
+        console.log(chalk.bold('\n🔓 SoulRecall Decrypt\n'));
+        try {
+            await executeDecrypt(file, options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red(`\nError: ${message}`));
+            process.exit(1);
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=decrypt.js.map

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

@@ -0,0 +1,32 @@
+/**
+ * Deploy command - Deploy agent WASM to ICP canister
+ */
+import { Command } from 'commander';
+import { type DeployResult, type NetworkType } from '../../src/deployment/index.js';
+export interface DeployCommandOptions {
+    network?: NetworkType;
+    canisterId?: string;
+    yes?: boolean;
+    dryRun?: boolean;
+    env?: string;
+    identity?: string;
+    cycles?: string;
+    mode?: 'auto' | 'install' | 'reinstall' | 'upgrade';
+}
+/**
+ * Display deployment preview (dry-run)
+ */
+export declare function displayPreview(wasmPath: string, options: DeployCommandOptions): void;
+/**
+ * Display deployment result
+ */
+export declare function displayResult(result: DeployResult): void;
+/**
+ * Execute the deploy command
+ */
+export declare function executeDeploy(wasmPath: string, options: DeployCommandOptions): Promise<DeployResult | null>;
+/**
+ * Create the deploy command
+ */
+export declare function deployCommand(): Command;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/cli/commands/deploy.js

@@ -0,0 +1,208 @@
+/**
+ * Deploy command - Deploy agent WASM to ICP canister
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import * as path from 'node:path';
+import { deployAgent, getDeploySummary, } from '../../src/deployment/index.js';
+/**
+ * Format cycles for display
+ */
+function formatCycles(cycles) {
+    if (cycles >= BigInt(1_000_000_000_000)) {
+        return `${(Number(cycles) / 1_000_000_000_000).toFixed(2)} T`;
+    }
+    if (cycles >= BigInt(1_000_000_000)) {
+        return `${(Number(cycles) / 1_000_000_000).toFixed(2)} B`;
+    }
+    if (cycles >= BigInt(1_000_000)) {
+        return `${(Number(cycles) / 1_000_000).toFixed(2)} M`;
+    }
+    return `${cycles.toString()}`;
+}
+/**
+ * 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 deployment preview (dry-run)
+ */
+export function displayPreview(wasmPath, options) {
+    const summary = getDeploySummary({
+        wasmPath: path.resolve(wasmPath),
+        network: options.network ?? 'local',
+        canisterId: options.canisterId,
+        skipConfirmation: options.yes,
+    });
+    console.log(chalk.bold('\nDeployment Preview\n'));
+    console.log(chalk.cyan('Agent:'));
+    console.log(`  Name:      ${chalk.bold(summary.agentName)}`);
+    console.log(`  WASM:      ${summary.wasmPath}`);
+    console.log(`  Size:      ${formatSize(summary.wasmSize)}`);
+    if (summary.wasmHash) {
+        console.log(`  Hash:      ${summary.wasmHash.substring(0, 16)}...`);
+    }
+    console.log();
+    console.log(chalk.cyan('Target:'));
+    console.log(`  Network:   ${chalk.bold(summary.network)}`);
+    console.log(`  Operation: ${summary.isUpgrade ? chalk.yellow('Upgrade') : chalk.green('New Deploy')}`);
+    if (summary.canisterId) {
+        console.log(`  Canister:  ${summary.canisterId}`);
+    }
+    console.log();
+    if (summary.validation.warnings.length > 0) {
+        console.log(chalk.yellow('Warnings:'));
+        for (const warning of summary.validation.warnings) {
+            console.log(chalk.yellow(`  ⚠ ${warning}`));
+        }
+        console.log();
+    }
+    if (summary.validation.errors.length > 0) {
+        console.log(chalk.red('Errors:'));
+        for (const error of summary.validation.errors) {
+            console.log(chalk.red(`  ✖ ${error.message}`));
+        }
+        console.log();
+    }
+}
+/**
+ * Display deployment result
+ */
+export function displayResult(result) {
+    console.log();
+    console.log(chalk.green('✓'), 'Agent deployed successfully!');
+    console.log();
+    console.log(chalk.cyan('Canister Info:'));
+    console.log(`  Canister ID: ${chalk.bold(result.canister.canisterId)}`);
+    console.log(`  Network:     ${result.canister.network}`);
+    console.log(`  Agent:       ${result.canister.agentName}`);
+    console.log(`  Deployed:    ${result.canister.deployedAt.toISOString()}`);
+    if (result.canister.wasmHash) {
+        console.log(`  WASM Hash:   ${result.canister.wasmHash.substring(0, 16)}...`);
+    }
+    if (result.cyclesUsed) {
+        console.log(`  Cycles Used: ${formatCycles(result.cyclesUsed)}`);
+    }
+    if (result.deployTool) {
+        console.log(`  Deploy Tool: ${result.deployTool}`);
+    }
+    if (result.warnings.length > 0) {
+        console.log();
+        console.log(chalk.yellow('Warnings:'));
+        for (const warning of result.warnings) {
+            console.log(chalk.yellow(`  ⚠ ${warning}`));
+        }
+    }
+    console.log();
+    console.log(chalk.cyan('Next steps:'));
+    if (result.canister.network === 'local') {
+        console.log('  1. Test your agent locally with dfx');
+        console.log('  2. Deploy to IC mainnet with', chalk.bold('--network ic'));
+    }
+    else {
+        console.log('  1. Interact with your canister at:');
+        console.log(`     ${chalk.bold(`https://${result.canister.canisterId}.ic0.app`)}`);
+        console.log('  2. Monitor cycles balance with', chalk.bold('dfx canister status'));
+    }
+}
+/**
+ * Prompt for deployment confirmation
+ */
+async function confirmDeployment(network, isUpgrade) {
+    const action = isUpgrade ? 'upgrade' : 'deploy';
+    const networkLabel = network === 'ic' ? 'IC mainnet' : 'local network';
+    const { confirmed } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirmed',
+            message: `${action.charAt(0).toUpperCase() + action.slice(1)} to ${networkLabel}?`,
+            default: network === 'local',
+        },
+    ]);
+    return confirmed;
+}
+/**
+ * Execute the deploy command
+ */
+export async function executeDeploy(wasmPath, options) {
+    const resolvedPath = path.resolve(wasmPath);
+    const network = options.network ?? 'local';
+    // Handle dry-run mode
+    if (options.dryRun) {
+        displayPreview(resolvedPath, options);
+        return null;
+    }
+    // Confirm deployment unless --yes flag
+    if (!options.yes) {
+        const confirmed = await confirmDeployment(network, !!options.canisterId);
+        if (!confirmed) {
+            console.log(chalk.yellow('\nDeployment cancelled.'));
+            return null;
+        }
+    }
+    const spinner = ora('Deploying agent to ICP...').start();
+    try {
+        // Prepare deploy options
+        const deployOptions = {
+            wasmPath: resolvedPath,
+            network,
+            canisterId: options.canisterId,
+            skipConfirmation: options.yes,
+            environment: options.env,
+            identity: options.identity,
+            cycles: options.cycles,
+            mode: options.mode,
+        };
+        // Execute deployment
+        const result = await deployAgent(deployOptions);
+        const action = result.isUpgrade ? 'upgraded' : 'deployed';
+        spinner.succeed(`Agent '${result.canister.agentName}' ${action} successfully!`);
+        displayResult(result);
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Deployment failed: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Create the deploy command
+ */
+export function deployCommand() {
+    const command = new Command('deploy');
+    command
+        .description('Deploy agent WASM to ICP canister')
+        .argument('<wasm>', 'path to compiled WASM file')
+        .option('-n, --network <network>', 'target network (local or ic)', 'local')
+        .option('-e, --env <environment>', 'named environment from icp.yaml (e.g. dev, staging, production)')
+        .option('-c, --canister-id <id>', 'existing canister ID (for upgrades)')
+        .option('-y, --yes', 'skip confirmation prompts')
+        .option('--dry-run', 'show what would be deployed without executing')
+        .option('--identity <name>', 'identity name for icp-cli')
+        .option('--cycles <amount>', 'cycles allocation (e.g. 100T)')
+        .option('--mode <mode>', 'deploy mode: auto, install, reinstall, upgrade')
+        .action(async (wasm, options) => {
+        console.log(chalk.bold('\n🚀 SoulRecall Deploy\n'));
+        try {
+            await executeDeploy(wasm, options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red(`\nError: ${message}`));
+            process.exit(1);
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=deploy.js.map