agentvault 1.0.0

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

@@ -0,0 +1,26 @@
+/**
+ * Exec command - Run agent on-chain
+ */
+import { Command } from 'commander';
+import type { NetworkType } from '../../src/deployment/types.js';
+export interface ExecCommandOptions {
+    network?: NetworkType;
+    async?: boolean;
+    polling?: boolean;
+}
+export interface TaskResult {
+    taskId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    result?: unknown;
+    error?: string;
+    cyclesUsed?: bigint;
+}
+/**
+ * Execute exec command
+ */
+export declare function executeExec(canisterId: string, task: string, options: ExecCommandOptions): Promise<TaskResult>;
+/**
+ * Create exec command
+ */
+export declare function execCommand(): Command;
+//# sourceMappingURL=exec.d.ts.map

package/dist/cli/commands/exec.js

@@ -0,0 +1,109 @@
+/**
+ * Exec command - Run agent on-chain
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createICPClient } from '../../src/deployment/icpClient.js';
+/**
+ * Execute exec command
+ */
+export async function executeExec(canisterId, task, options) {
+    const network = options.network ?? 'local';
+    const resolvedCanisterId = canisterId.trim();
+    // Validate canister ID
+    if (!/^[a-z0-9-]{27}$/.test(resolvedCanisterId)) {
+        throw new Error(`Invalid canister ID format: ${resolvedCanisterId}. Expected 27 characters of alphanumeric and hyphens.`);
+    }
+    const spinner = ora('Executing task on canister...').start();
+    try {
+        // Create ICP client
+        const client = createICPClient({ network });
+        // Check connection
+        const connectionCheck = await client.checkConnection();
+        if (!connectionCheck.connected) {
+            throw new Error(`Failed to connect to ${network} network: ${connectionCheck.error ?? 'Unknown error'}`);
+        }
+        // Check canister status
+        spinner.text = 'Checking canister status...';
+        const status = await client.getCanisterStatus(resolvedCanisterId);
+        if (status.status !== 'running') {
+            throw new Error(`Canister is not running. Status: ${status.status}`);
+        }
+        // Submit task to canister
+        spinner.text = 'Submitting task...';
+        const executionResult = await client.callAgentMethod(resolvedCanisterId, 'execute', [task]);
+        const taskId = `task_${Date.now()}`;
+        spinner.succeed('Task submitted successfully!');
+        console.log();
+        console.log(chalk.cyan('Task Info:'));
+        console.log(`  Canister:  ${chalk.bold(resolvedCanisterId)}`);
+        console.log(`  Network:   ${network}`);
+        console.log(`  Task ID:    ${taskId}`);
+        console.log(`  Command:    ${task}`);
+        // Poll for completion if requested
+        if (options.polling && !options.async) {
+            const newSpinner = ora('Waiting for task completion...');
+            return await pollForCompletion(client, resolvedCanisterId, taskId, executionResult, newSpinner);
+        }
+        // Return async result
+        return {
+            taskId,
+            status: 'pending',
+            result: executionResult,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Execution failed: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Poll for task completion
+ */
+async function pollForCompletion(_client, _canisterId, taskId, executionResult, spinner) {
+    spinner.start('Finalizing task result...');
+    spinner.succeed('Task completed!');
+    console.log();
+    console.log(chalk.green('✓'), 'Task executed successfully!');
+    return {
+        taskId,
+        status: 'completed',
+        result: executionResult,
+    };
+}
+/**
+ * Create exec command
+ */
+export function execCommand() {
+    const command = new Command('exec');
+    command
+        .description('Run agent task on-chain')
+        .argument('<canister-id>', 'canister ID to execute on')
+        .argument('<task>', 'task/command to execute')
+        .option('-n, --network <network>', 'network (local or ic)', 'local')
+        .option('-a, --async', 'return immediately without waiting for completion')
+        .option('-p, --polling', 'poll for task completion (default: true)')
+        .action(async (canisterId, task, options) => {
+        console.log(chalk.bold('\n⚡ SoulRecall Exec\n'));
+        try {
+            const result = await executeExec(canisterId, task, options);
+            if (options.async || options.polling === false) {
+                console.log();
+                console.log(chalk.cyan('Task Info:'));
+                console.log(`  Task ID:  ${result.taskId}`);
+                console.log(`  Status:   ${result.status}`);
+                console.log();
+                console.log('Use', chalk.bold('soulrecall show'), 'to check task status.');
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red(`\nError: ${message}`));
+            process.exit(1);
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=exec.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * Fetch command - Download agent state from canister
+ */
+import { Command } from 'commander';
+import type { NetworkType } from '../../src/deployment/types.js';
+export interface FetchCommandOptions {
+    network?: NetworkType;
+    output?: string;
+    decrypt?: boolean;
+}
+export interface FetchAnswers {
+    seedPhrase?: string;
+    confirm: boolean;
+}
+/**
+ * Execute the fetch command
+ */
+export declare function executeFetch(canisterId: string, options: FetchCommandOptions): Promise<void>;
+/**
+ * Create the fetch command
+ */
+export declare function fetchCommand(): Command;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/cli/commands/fetch.js

@@ -0,0 +1,164 @@
+/**
+ * Fetch command - Download agent state from canister
+ */
+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 { createICPClient } from '../../src/deployment/icpClient.js';
+/**
+ * Execute the fetch command
+ */
+export async function executeFetch(canisterId, options) {
+    const network = options.network ?? 'local';
+    const resolvedCanisterId = canisterId.trim();
+    // Validate canister ID format
+    if (!/^[a-z0-9-]{27}$/.test(resolvedCanisterId)) {
+        throw new Error(`Invalid canister ID format: ${resolvedCanisterId}. Expected 27 characters of alphanumeric and hyphens.`);
+    }
+    // Determine output path
+    const outputPath = options.output ?? path.resolve(process.cwd(), `${resolvedCanisterId}.state.json`);
+    // Check if output already exists
+    if (fs.existsSync(outputPath) && !options.decrypt) {
+        const { overwrite } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Output file ${outputPath} already exists. Overwrite?`,
+                default: false,
+            },
+        ]);
+        if (!overwrite) {
+            console.log(chalk.yellow('\nFetch cancelled.'));
+            return;
+        }
+    }
+    const spinner = ora('Fetching agent state from canister...').start();
+    try {
+        // Create ICP client
+        const client = createICPClient({ network });
+        // Check connection
+        const connectionCheck = await client.checkConnection();
+        if (!connectionCheck.connected) {
+            throw new Error(`Failed to connect to ${network} network: ${connectionCheck.error ?? 'Unknown error'}`);
+        }
+        // Fetch state from canister
+        spinner.text = 'Querying canister state...';
+        const canisterStatus = await client.getCanisterStatus(resolvedCanisterId);
+        const [agentStateResult, memoriesResult, tasksResult, contextResult] = await Promise.allSettled([
+            client.callAgentMethod(resolvedCanisterId, 'agent_get_state'),
+            client.callAgentMethod(resolvedCanisterId, 'agent_get_memories'),
+            client.callAgentMethod(resolvedCanisterId, 'agent_get_tasks'),
+            client.callAgentMethod(resolvedCanisterId, 'getAllContext'),
+        ]);
+        const stateData = {
+            canisterId: resolvedCanisterId,
+            network,
+            fetchedAt: new Date().toISOString(),
+            canisterStatus,
+            state: {
+                initialized: canisterStatus.exists,
+                data: {
+                    agentState: agentStateResult.status === 'fulfilled' ? agentStateResult.value : null,
+                    memories: memoriesResult.status === 'fulfilled' ? memoriesResult.value : [],
+                    tasks: tasksResult.status === 'fulfilled' ? tasksResult.value : [],
+                    context: contextResult.status === 'fulfilled' ? contextResult.value : {},
+                },
+            },
+        };
+        spinner.succeed('Agent state fetched successfully!');
+        console.log();
+        console.log(chalk.cyan('Canister Info:'));
+        console.log(`  ID:        ${chalk.bold(stateData.canisterId)}`);
+        console.log(`  Network:   ${stateData.network}`);
+        console.log(`  Fetched:   ${stateData.fetchedAt}`);
+        // Write state to file
+        if (!options.decrypt) {
+            fs.writeFileSync(outputPath, JSON.stringify(stateData, null, 2), 'utf-8');
+            console.log();
+            console.log(chalk.green('✓'), 'State saved to:', chalk.bold(outputPath));
+            console.log();
+            console.log(chalk.cyan('Next steps:'));
+            console.log('  1. Decrypt the state:', chalk.bold('soulrecall decrypt'), `<${outputPath}>`);
+            console.log('  2. Rebuild the agent:', chalk.bold('soulrecall rebuild'));
+        }
+        // Handle decryption if requested
+        if (options.decrypt) {
+            await handleDecryption(stateData, outputPath);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Fetch failed: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Handle decryption of fetched state
+ */
+async function handleDecryption(stateData, outputPath) {
+    console.log();
+    console.log(chalk.cyan('Decryption required.'));
+    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 state...').start();
+    try {
+        // Stub: In a real implementation, this would decrypt using VetKeys
+        const decryptedState = stateData;
+        spinner.succeed('State decrypted successfully!');
+        fs.writeFileSync(outputPath, JSON.stringify(decryptedState, 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 the agent:', chalk.bold('soulrecall rebuild'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`Decryption failed: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Create the fetch command
+ */
+export function fetchCommand() {
+    const command = new Command('fetch');
+    command
+        .description('Download agent state from canister')
+        .argument('<canister-id>', 'canister ID to fetch state from')
+        .option('-n, --network <network>', 'network (local or ic)', 'local')
+        .option('-o, --output <path>', 'output file path')
+        .option('-d, --decrypt', 'decrypt state after fetching')
+        .action(async (canisterId, options) => {
+        console.log(chalk.bold('\n📥 SoulRecall Fetch\n'));
+        try {
+            await executeFetch(canisterId, options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red(`\nError: ${message}`));
+            process.exit(1);
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=fetch.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Health Command
+ *
+ * Checks canister health and displays alerts.
+ */
+import { Command } from 'commander';
+export declare function healthCommand(): Command;
+//# sourceMappingURL=health.d.ts.map

package/dist/cli/commands/health.js

@@ -0,0 +1,72 @@
+/**
+ * Health Command
+ *
+ * Checks canister health and displays alerts.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { checkHealth, getRecentAlerts } from '../../src/monitoring/index.js';
+export function healthCommand() {
+    const command = new Command('health');
+    command
+        .description('Check canister health and display alerts')
+        .argument('<canister-id>', 'Canister ID to check')
+        .option('-t, --thresholds <json>', 'Health check thresholds as JSON')
+        .option('-i, --interval <ms>', 'Polling interval in milliseconds')
+        .option('--max-alerts <n>', 'Maximum alerts to display')
+        .option('--clear', 'Clear all alerts for canister')
+        .option('-w, --watch', 'Watch canister health continuously');
+    command
+        .action(async (canisterId, options) => {
+        const thresholds = options.thresholds ? JSON.parse(options.thresholds) : undefined;
+        const monitoringOpts = {
+            canister: canisterId,
+            thresholds,
+            pollInterval: options.interval ? parseInt(options.interval) : undefined,
+            maxSnapshots: options.maxAlerts ? parseInt(options.maxAlerts) : 10,
+        };
+        const spinner = ora('Checking canister health...').start();
+        try {
+            const statusInfo = await checkHealth(canisterId, monitoringOpts);
+            spinner.succeed('Health check completed');
+            displayHealth(statusInfo);
+            const alerts = await getRecentAlerts(canisterId, monitoringOpts.maxSnapshots || 10);
+            if (alerts.length > 0) {
+                console.log();
+                console.log(chalk.cyan('Recent Alerts:'));
+                for (const alert of alerts) {
+                    const severityColor = alert.severity === 'critical'
+                        ? chalk.red
+                        : alert.severity === 'warning'
+                            ? chalk.yellow
+                            : chalk.gray;
+                    console.log(`  [${new Date(alert.timestamp).toISOString()}]`, `  ${severityColor(alert.severity)} ${alert.severity.toUpperCase()}:`, `  Canister: ${alert.canisterId}`, `  Metric: ${alert.metric}`, `  Value: ${alert.value}`, `  Threshold: ${alert.threshold}`);
+                }
+            }
+            else {
+                console.log(chalk.gray('No recent alerts'));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            spinner.fail(`Health check failed: ${message}`);
+            throw error;
+        }
+    });
+    return command;
+}
+function displayHealth(statusInfo) {
+    console.log();
+    console.log(chalk.cyan('Canister Status:'), chalk.bold(statusInfo.status));
+    console.log();
+    console.log(chalk.cyan('Health Check:'), statusInfo.health === 'healthy' ? chalk.green('Passed') : chalk.red('Failed'));
+    if (statusInfo.memorySize !== undefined) {
+        const memoryMB = Number(statusInfo.memorySize) / (1024 * 1024);
+        console.log(chalk.cyan('Memory:'), chalk.bold(`${memoryMB.toFixed(2)} MB`));
+    }
+    if (statusInfo.cycles !== undefined) {
+        console.log(chalk.cyan('Cycles:'), chalk.bold(statusInfo.cycles.toString()));
+    }
+}
+//# sourceMappingURL=health.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Identity Command
+ *
+ * Manages identities for ICP operations.
+ */
+import { Command } from 'commander';
+export declare function identityCommand(): Command;
+//# sourceMappingURL=identity.d.ts.map

package/dist/cli/commands/identity.js

@@ -0,0 +1,140 @@
+/**
+ * Identity Command
+ *
+ * Manages identities for ICP operations.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { listIdentities, createIdentity, exportIdentity, getIdentityPrincipal, importIdentity, setDefaultIdentity, } from '../../src/icp/identity.js';
+export function identityCommand() {
+    const command = new Command('identity');
+    command
+        .description('Manage ICP identities')
+        .action(() => {
+        command.outputHelp();
+    })
+        .addCommand(listSubcommand())
+        .addCommand(createSubcommand())
+        .addCommand(exportSubcommand())
+        .addCommand(importSubcommand())
+        .addCommand(principalSubcommand())
+        .addCommand(defaultSubcommand());
+    return command;
+}
+async function executeList() {
+    const spinner = ora('Listing identities...').start();
+    try {
+        const result = await listIdentities();
+        spinner.succeed('Identities listed successfully');
+        console.log();
+        console.log(chalk.cyan('Available Identities:'));
+        console.log(result.stdout || 'No identities found');
+    }
+    catch (error) {
+        spinner.fail(`Failed to list identities: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+async function executeCreate(options) {
+    const { name } = options;
+    const spinner = ora('Creating identity...').start();
+    try {
+        await createIdentity(name);
+        spinner.succeed(`Identity '${name}' created successfully`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to create identity: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+async function executeExport(options) {
+    const { name } = options;
+    const spinner = ora('Exporting identity...').start();
+    try {
+        const result = await exportIdentity(name);
+        spinner.succeed(`Identity '${name}' exported successfully`);
+        console.log();
+        console.log(chalk.cyan('PEM Content:'));
+        console.log(result.stdout || 'No PEM content returned');
+    }
+    catch (error) {
+        spinner.fail(`Failed to export identity: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+async function executeImport(options) {
+    const { name, pemFile } = options;
+    const spinner = ora('Importing identity...').start();
+    try {
+        await importIdentity(name, pemFile);
+        spinner.succeed(`Identity '${name}' imported successfully`);
+        console.log(chalk.cyan('Imported from:'), pemFile);
+    }
+    catch (error) {
+        spinner.fail(`Failed to import identity: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+async function executePrincipal(options) {
+    const { name } = options;
+    const spinner = ora('Getting identity principal...').start();
+    try {
+        const result = await getIdentityPrincipal(name);
+        spinner.succeed(`Identity '${name}' principal: ${result || 'N/A'}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to get identity principal: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+async function executeSetDefault(options) {
+    const { name } = options;
+    const spinner = ora('Setting default identity...').start();
+    try {
+        await setDefaultIdentity(name);
+        spinner.succeed(`Identity '${name}' set as default`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to set default identity: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}
+function listSubcommand() {
+    return new Command('list')
+        .description('List all ICP identities')
+        .action(executeList);
+}
+function createSubcommand() {
+    return new Command('create')
+        .description('Create a new ICP identity')
+        .argument('<name>', 'Identity name')
+        .action(executeCreate);
+}
+function exportSubcommand() {
+    return new Command('export')
+        .description('Export identity to PEM file')
+        .argument('<name>', 'Identity name')
+        .argument('[pem-file]', 'Path to PEM file')
+        .action(executeExport);
+}
+function importSubcommand() {
+    return new Command('import')
+        .description('Import identity from PEM file')
+        .argument('<name>', 'Identity name')
+        .argument('[pem-file]', 'Path to PEM file')
+        .action(executeImport);
+}
+function principalSubcommand() {
+    return new Command('principal')
+        .description('Get the principal of an identity')
+        .argument('[name]', 'Identity name (optional)')
+        .action(executePrincipal);
+}
+function defaultSubcommand() {
+    return new Command('default')
+        .description('Set the default identity')
+        .argument('<name>', 'Identity name')
+        .action(executeSetDefault);
+}
+//# sourceMappingURL=identity.js.map

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

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