agentvault 1.0.0

package/dist/cli/commands/list.js

@@ -0,0 +1,173 @@
+/**
+ * List command - List all agents
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Get list of all agents
+ */
+export async function getAgents(options) {
+    const agents = [];
+    // Get agents from local filesystem
+    const localAgents = await getLocalAgents();
+    if (options.local || !options.deployed) {
+        agents.push(...localAgents);
+    }
+    // In a real implementation, this would query deployed canisters
+    if (options.deployed || options.all) {
+        const deployedAgents = await getDeployedAgents();
+        agents.push(...deployedAgents);
+    }
+    return agents;
+}
+/**
+ * Get local agents from filesystem
+ */
+async function getLocalAgents() {
+    const agents = [];
+    // Check for soulrecall directory
+    const agentDir = path.join(process.cwd(), '.soulrecall');
+    if (fs.existsSync(agentDir)) {
+        const agentsDir = path.join(agentDir, 'agents');
+        if (fs.existsSync(agentsDir)) {
+            const entries = fs.readdirSync(agentsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const agentPath = path.join(agentsDir, entry.name);
+                    const stateFile = path.join(agentPath, 'state.json');
+                    if (fs.existsSync(stateFile)) {
+                        try {
+                            const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+                            agents.push({
+                                name: entry.name,
+                                type: state.agent?.type || 'generic',
+                                sourcePath: agentPath,
+                                deployed: false,
+                                lastUpdated: state.metadata?.createdAt,
+                            });
+                        }
+                        catch {
+                            // Skip invalid state files
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Also check for dist directories with WASM files
+    const distDir = path.join(process.cwd(), 'dist');
+    if (fs.existsSync(distDir)) {
+        const entries = fs.readdirSync(distDir);
+        for (const entry of entries) {
+            if (entry.endsWith('.wasm')) {
+                const name = entry.replace('.wasm', '');
+                const stateFile = path.join(distDir, `${name}.state.json`);
+                if (fs.existsSync(stateFile)) {
+                    try {
+                        const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+                        agents.push({
+                            name,
+                            type: state.agent?.type || 'generic',
+                            sourcePath: process.cwd(),
+                            deployed: false,
+                            lastUpdated: state.metadata?.createdAt,
+                        });
+                    }
+                    catch {
+                        agents.push({
+                            name,
+                            type: 'generic',
+                            sourcePath: process.cwd(),
+                            deployed: false,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return agents;
+}
+/**
+ * Get deployed agents (stub)
+ */
+async function getDeployedAgents() {
+    // Stub: In a real implementation, this would query the canister registry
+    return [];
+}
+/**
+ * Display list of agents
+ */
+export function displayAgents(agents, options) {
+    if (options.json) {
+        console.log(JSON.stringify(agents, null, 2));
+        return;
+    }
+    console.log();
+    if (agents.length === 0) {
+        console.log(chalk.yellow('No agents found.'));
+        console.log();
+        console.log('Create a new agent with:', chalk.bold('soulrecall init'));
+        return;
+    }
+    console.log(chalk.cyan(`Found ${agents.length} agent(s):\n`));
+    for (const agent of agents) {
+        console.log(chalk.bold(agent.name));
+        console.log(`  Type:     ${agent.type}`);
+        console.log(`  Source:    ${agent.sourcePath}`);
+        if (agent.deployed && agent.canisterId) {
+            console.log(`  Canister:  ${agent.canisterId}`);
+            console.log(`  Network:   ${agent.network}`);
+        }
+        else {
+            console.log(`  Status:    ${chalk.yellow('Not deployed')}`);
+        }
+        if (agent.lastUpdated) {
+            console.log(`  Updated:   ${agent.lastUpdated}`);
+        }
+        console.log();
+    }
+}
+/**
+ * Execute list command
+ */
+export async function executeList(options) {
+    const spinner = ora('Scanning for agents...').start();
+    try {
+        const agents = await getAgents(options);
+        spinner.succeed('Scan complete!');
+        displayAgents(agents, options);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        spinner.fail(`List failed: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Create list command
+ */
+export function listCommand() {
+    const command = new Command('list');
+    command
+        .description('List all agents')
+        .option('-a, --all', 'show all agents (local and deployed)')
+        .option('--deployed', 'show only deployed agents')
+        .option('--local', 'show only local agents')
+        .option('-j, --json', 'output as JSON')
+        .action(async (options) => {
+        console.log(chalk.bold('\n📋 SoulRecall List\n'));
+        try {
+            await executeList(options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red(`\nError: ${message}`));
+            process.exit(1);
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=list.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Logs CLI commands
+ *
+ * Provides commands for viewing, filtering, and exporting canister logs
+ */
+import { Command } from 'commander';
+export declare const logsCmd: Command;
+//# sourceMappingURL=logs.d.ts.map

package/dist/cli/commands/logs.js

@@ -0,0 +1,96 @@
+/**
+ * Logs CLI commands
+ *
+ * Provides commands for viewing, filtering, and exporting canister logs
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getLogs, exportLogs, clearLogs } from '../../src/debugging/logs.js';
+export const logsCmd = new Command('logs');
+logsCmd
+    .description('View and manage canister logs')
+    .argument('<canister-id>', 'Canister ID')
+    .option('-t, --tail', 'Tail logs (follow mode)', false)
+    .option('-f, --filter <pattern>', 'Filter logs by pattern')
+    .option('-l, --level <level>', 'Filter by log level (info, warning, error, debug)')
+    .option('-s, --since <time>', 'Show logs since timestamp')
+    .option('-n, --limit <num>', 'Limit number of log entries')
+    .option('-e, --export <file>', 'Export logs to file')
+    .option('--format <format>', 'Export format (json, csv)', 'json')
+    .option('--clear', 'Clear all logs for this canister', false)
+    .action(async (canisterId, options) => {
+    if (options.clear) {
+        const spinner = ora(`Clearing logs for ${canisterId}...`).start();
+        try {
+            await clearLogs(canisterId);
+            spinner.succeed(chalk.green('Logs cleared'));
+            return;
+        }
+        catch (error) {
+            spinner.fail(chalk.red('Failed to clear logs'));
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red(message));
+            process.exit(1);
+        }
+    }
+    const spinner = ora('Fetching logs...').start();
+    try {
+        const since = options.since ? new Date(options.since) : undefined;
+        const level = options.level;
+        const limit = options.limit ? parseInt(options.limit, 10) : undefined;
+        const logs = await getLogs(canisterId, {
+            since,
+            level,
+            pattern: options.filter,
+            limit,
+        });
+        spinner.stop();
+        if (logs.length === 0) {
+            console.log(chalk.yellow('No logs found'));
+            return;
+        }
+        if (options.export) {
+            const exportSpinner = ora(`Exporting logs to ${options.export}...`).start();
+            try {
+                await exportLogs(canisterId, options.export, options.format);
+                exportSpinner.succeed(chalk.green(`Logs exported to ${options.export}`));
+                return;
+            }
+            catch (error) {
+                exportSpinner.fail(chalk.red('Failed to export logs'));
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                console.error(chalk.red(message));
+                process.exit(1);
+            }
+        }
+        const levelColors = {
+            info: chalk.blue,
+            warning: chalk.yellow,
+            error: chalk.red,
+            debug: chalk.gray,
+        };
+        for (const log of logs) {
+            const levelColor = levelColors[log.level];
+            const timestamp = log.timestamp.toISOString();
+            const level = log.level.toUpperCase().padEnd(7);
+            const method = log.method ? ` [${log.method}]` : '';
+            console.log(levelColor(`${timestamp} [${level}]${method}`));
+            console.log(`  ${log.message}`);
+            if (log.context && Object.keys(log.context).length > 0) {
+                console.log(chalk.gray('  Context: ' + JSON.stringify(log.context, null, 2).split('\n').join('\n  ')));
+            }
+            console.log();
+        }
+        if (!options.tail) {
+            console.log(chalk.gray(`Showing ${logs.length} log entries`));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to fetch logs'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=logs.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * Monitor Command
+ *
+ * Watches canister health and displays real-time metrics.
+ */
+import { Command } from 'commander';
+export declare function monitorCommand(): Command;
+//# sourceMappingURL=monitor.d.ts.map

package/dist/cli/commands/monitor.js

@@ -0,0 +1,84 @@
+/**
+ * Monitor Command
+ *
+ * Watches canister health and displays real-time metrics.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { checkHealth, getRecentAlerts } from '../../src/monitoring/index.js';
+export function monitorCommand() {
+    const command = new Command('monitor');
+    command
+        .description('Watch canister health in real-time')
+        .argument('<canister-id>', 'Canister ID to monitor')
+        .option('-i, --interval <ms>', 'Polling interval (default: 10s)')
+        .option('-t, --thresholds <json>', 'Health check thresholds as JSON')
+        .option('-a, --alerts', 'Display all alerts (default: latest 10)');
+    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) : 10000,
+            maxSnapshots: options.alerts ? parseInt(options.alerts) : 10,
+        };
+        const spinner = ora(`Monitoring canister ${canisterId}...`).start();
+        try {
+            await checkHealth(canisterId, monitoringOpts);
+            spinner.succeed(`Monitoring ${canisterId} started`);
+            console.log(chalk.gray(`Press Ctrl+C to stop monitoring`));
+            const pollInterval = monitoringOpts.pollInterval || 10000;
+            console.log(chalk.cyan(`Polling every ${(pollInterval / 1000).toFixed(1)}s`));
+            while (true) {
+                const statusInfo = await checkHealth(canisterId, monitoringOpts);
+                if (statusInfo.status === 'stopped') {
+                    console.log(chalk.yellow('Canister stopped - stopping monitoring'));
+                    break;
+                }
+                displayStatus(statusInfo);
+                if (monitoringOpts.generateAlerts !== false) {
+                    const alerts = await getRecentAlerts(canisterId, monitoringOpts.maxSnapshots);
+                    if (alerts.length > 0) {
+                        displayAlerts(alerts);
+                    }
+                }
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                console.log(chalk.gray('\nMonitoring stopped'));
+                process.exit(0);
+            }
+            else {
+                spinner.fail(`Monitoring error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                throw error;
+            }
+        }
+    });
+    return command;
+}
+function displayStatus(statusInfo) {
+    console.log();
+    console.log(chalk.cyan('Status:'), statusInfo.status);
+    console.log(chalk.cyan('Memory:'), statusInfo.memorySize ? `${(Number(statusInfo.memorySize) / (1024 * 1024)).toFixed(2)} MB` : 'N/A');
+    console.log(chalk.cyan('Cycles:'), statusInfo.cycles ? statusInfo.cycles.toString() : 'N/A');
+    console.log(chalk.cyan('Health:'), statusInfo.health);
+}
+function displayAlerts(alerts) {
+    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;
+        const timestamp = new Date(alert.timestamp).toISOString();
+        const truncatedMetric = alert.metric.length > 30 ? `${alert.metric.substring(0, 30)}...` : alert.metric;
+        console.log(`  [${timestamp}]`, `  ${severityColor(alert.severity)} ${alert.severity.toUpperCase()}:`, `  Canister: ${alert.canisterId}`, `  ${truncatedMetric}`, `  Value: ${alert.value}`, `  Threshold: ${alert.threshold}`);
+    }
+}
+//# sourceMappingURL=monitor.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * Network management CLI commands
+ *
+ * Provides commands for managing local ICP networks:
+ * - create: Create a new network configuration
+ * - start: Start a local network
+ * - stop: Stop a running network
+ * - status: Get network status
+ * - list: List all networks
+ * - ping: Check network connectivity
+ */
+import { Command } from 'commander';
+export declare const networkCmd: Command;
+//# sourceMappingURL=network.d.ts.map

package/dist/cli/commands/network.js

@@ -0,0 +1,258 @@
+/**
+ * Network management CLI commands
+ *
+ * Provides commands for managing local ICP networks:
+ * - create: Create a new network configuration
+ * - start: Start a local network
+ * - stop: Stop a running network
+ * - status: Get network status
+ * - list: List all networks
+ * - ping: Check network connectivity
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { networkStart, networkStop, networkStatus, networkList, networkPing, } from '../../src/icp/icpcli.js';
+import { createNetworkConfig, getNetworkConfig, listNetworkConfigs, setNetworkStatus, } from '../../src/network/network-config.js';
+export const networkCmd = new Command('network');
+networkCmd
+    .description('Manage ICP networks');
+const createCmd = new Command('create');
+createCmd
+    .description('Create a new network configuration')
+    .option('-n, --name <name>', 'Network name (required)')
+    .option('-t, --type <type>', 'Network type (local, ic)', 'local')
+    .option('--nodes <count>', 'Number of nodes', '4')
+    .option('--replica-count <count>', 'Replica count')
+    .option('--cycles-initial <amount>', 'Initial cycles allocation', '100T')
+    .option('--cycles-min <amount>', 'Minimum cycles threshold')
+    .option('--auto-topup', 'Enable automatic cycles top-up', false)
+    .action(async (options) => {
+    if (!options.name) {
+        console.error(chalk.red('Error: --name is required'));
+        process.exit(1);
+    }
+    const spinner = ora('Creating network configuration...').start();
+    try {
+        const config = await createNetworkConfig({
+            name: options.name,
+            type: options.type,
+            nodes: parseInt(options.nodes, 10),
+            replicaCount: options.replicaCount ? parseInt(options.replicaCount, 10) : undefined,
+            cycles: {
+                initial: options.cyclesInitial,
+                min: options.cyclesMin,
+                autoTopup: options.autoTopup,
+            },
+        });
+        spinner.succeed(chalk.green(`Network '${config.name}' created successfully`));
+        console.log(chalk.gray(`Type: ${config.type}`));
+        console.log(chalk.gray(`Replica count: ${config.replicaCount || config.nodes}`));
+        console.log(chalk.gray(`Initial cycles: ${config.cycles?.initial}`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to create network'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+const startCmd = new Command('start');
+startCmd
+    .description('Start a local network')
+    .argument('<name>', 'Network name')
+    .option('-e, --environment <env>', 'Environment name')
+    .option('--project-root <path>', 'Project root directory')
+    .option('--identity <name>', 'Identity to use')
+    .action(async (name, options) => {
+    const spinner = ora(`Starting network '${name}'...`).start();
+    try {
+        const config = await getNetworkConfig(name);
+        if (!config) {
+            spinner.fail(chalk.red(`Network '${name}' not found`));
+            process.exit(1);
+        }
+        const result = await networkStart({
+            network: name,
+            environment: options.environment,
+            projectRoot: options.projectRoot,
+            identity: options.identity,
+        });
+        if (!result.success) {
+            spinner.fail(chalk.red('Failed to start network'));
+            console.error(chalk.red(result.stderr));
+            process.exit(1);
+        }
+        await setNetworkStatus(name, 'running');
+        spinner.succeed(chalk.green(`Network '${name}' started successfully`));
+        console.log(result.stdout);
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to start network'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+const stopCmd = new Command('stop');
+stopCmd
+    .description('Stop a running network')
+    .argument('<name>', 'Network name')
+    .option('-e, --environment <env>', 'Environment name')
+    .option('--project-root <path>', 'Project root directory')
+    .option('--identity <name>', 'Identity to use')
+    .action(async (name, options) => {
+    const spinner = ora(`Stopping network '${name}'...`).start();
+    try {
+        const config = await getNetworkConfig(name);
+        if (!config) {
+            spinner.fail(chalk.red(`Network '${name}' not found`));
+            process.exit(1);
+        }
+        const result = await networkStop({
+            network: name,
+            environment: options.environment,
+            projectRoot: options.projectRoot,
+            identity: options.identity,
+        });
+        if (!result.success) {
+            spinner.fail(chalk.red('Failed to stop network'));
+            console.error(chalk.red(result.stderr));
+            process.exit(1);
+        }
+        await setNetworkStatus(name, 'stopped');
+        spinner.succeed(chalk.green(`Network '${name}' stopped successfully`));
+        console.log(result.stdout);
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to stop network'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+const statusCmd = new Command('status');
+statusCmd
+    .description('Get network status')
+    .argument('<name>', 'Network name')
+    .option('-e, --environment <env>', 'Environment name')
+    .option('--project-root <path>', 'Project root directory')
+    .option('--identity <name>', 'Identity to use')
+    .action(async (name, options) => {
+    const spinner = ora(`Checking network '${name}' status...`).start();
+    try {
+        const config = await getNetworkConfig(name);
+        if (!config) {
+            spinner.fail(chalk.red(`Network '${name}' not found`));
+            process.exit(1);
+        }
+        const result = await networkStatus({
+            environment: options.environment,
+            projectRoot: options.projectRoot,
+            identity: options.identity,
+        });
+        if (!result.success) {
+            spinner.warn(chalk.yellow('Could not get network status'));
+            console.error(chalk.red(result.stderr));
+            process.exit(1);
+        }
+        spinner.stop();
+        console.log(chalk.bold(`Network: ${name}`));
+        console.log(chalk.gray(`Type: ${config.type}`));
+        console.log(chalk.gray(`Status: ${config.status || 'unknown'}`));
+        console.log(chalk.gray(`Created: ${config.created?.toISOString() || 'unknown'}`));
+        console.log();
+        console.log(result.stdout);
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to get network status'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+const listCmd = new Command('list');
+listCmd
+    .description('List all networks')
+    .option('-e, --environment <env>', 'Environment name')
+    .option('--project-root <path>', 'Project root directory')
+    .option('--identity <name>', 'Identity to use')
+    .action(async (options) => {
+    const spinner = ora('Listing networks...').start();
+    try {
+        const configs = await listNetworkConfigs();
+        if (configs.length === 0) {
+            spinner.info(chalk.yellow('No networks found'));
+            return;
+        }
+        spinner.stop();
+        for (const config of configs) {
+            const statusColor = config.status === 'running' ? chalk.green : config.status === 'error' ? chalk.red : chalk.gray;
+            console.log(chalk.bold(config.name));
+            console.log(chalk.gray(`  Type: ${config.type}`));
+            console.log(chalk.gray(`  Status: ${statusColor(config.status || 'unknown')}`));
+            console.log(chalk.gray(`  Replicas: ${config.replicaCount || config.nodes}`));
+            if (config.cycles) {
+                console.log(chalk.gray(`  Initial cycles: ${config.cycles.initial}`));
+            }
+            console.log();
+        }
+        const result = await networkList({
+            environment: options.environment,
+            projectRoot: options.projectRoot,
+            identity: options.identity,
+        });
+        if (result.success) {
+            console.log(chalk.bold('ICP CLI networks:'));
+            console.log(result.stdout);
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to list networks'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+const pingCmd = new Command('ping');
+pingCmd
+    .description('Check network connectivity')
+    .argument('<name>', 'Network name')
+    .option('-e, --environment <env>', 'Environment name')
+    .option('--project-root <path>', 'Project root directory')
+    .option('--identity <name>', 'Identity to use')
+    .action(async (name, options) => {
+    const spinner = ora(`Pinging network '${name}'...`).start();
+    try {
+        const config = await getNetworkConfig(name);
+        if (!config) {
+            spinner.fail(chalk.red(`Network '${name}' not found`));
+            process.exit(1);
+        }
+        const result = await networkPing({
+            environment: options.environment,
+            projectRoot: options.projectRoot,
+            identity: options.identity,
+        });
+        if (!result.success) {
+            spinner.fail(chalk.red('Network ping failed'));
+            console.error(chalk.red(result.stderr));
+            process.exit(1);
+        }
+        spinner.succeed(chalk.green(`Network '${name}' is reachable`));
+        console.log(result.stdout);
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to ping network'));
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(chalk.red(message));
+        process.exit(1);
+    }
+});
+networkCmd.addCommand(createCmd);
+networkCmd.addCommand(startCmd);
+networkCmd.addCommand(stopCmd);
+networkCmd.addCommand(statusCmd);
+networkCmd.addCommand(listCmd);
+networkCmd.addCommand(pingCmd);
+//# sourceMappingURL=network.js.map

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

@@ -0,0 +1,36 @@
+/**
+ * Package command - Compile agent to WASM for deployment
+ */
+import { Command } from 'commander';
+import type { PackageResult } from '../../src/packaging/index.js';
+export interface PackageCommandOptions {
+    output?: string;
+    force?: boolean;
+    skipValidation?: boolean;
+    dryRun?: boolean;
+    target?: 'wasmedge' | 'motoko' | 'pure-wasm';
+    debug?: boolean;
+    optimize?: number;
+    icWasmOptimize?: boolean;
+    icWasmShrink?: boolean;
+    validate?: string;
+    memoryLimit?: string;
+    computeQuota?: string;
+}
+/**
+ * Display package preview (dry-run)
+ */
+export declare function displayPreview(sourcePath: string): void;
+/**
+ * Display package result
+ */
+export declare function displayResult(result: PackageResult): void;
+/**
+ * Execute the package command
+ */
+export declare function executePackage(sourcePath: string, options: PackageCommandOptions): Promise<PackageResult | null>;
+/**
+ * Create the package command
+ */
+export declare function packageCommand(): Command;
+//# sourceMappingURL=package.d.ts.map