@yamo/cli 1.3.13 → 1.3.14

package/README.md

@@ -90,6 +90,44 @@ yamo audit block_001
 yamo audit block_001 --key "my-secret"
 ```
 
+### `yamo config <action> [key] [value]`
+Manage local configuration and secrets persistently. Actions: `set`, `get`, `list`, `remove`.
+Values are stored in `~/.yamo/config.json`. Sensitive keys (e.g., `PRIVATE_KEY`) are masked in `list`.
+
+```bash
+# Set a configuration value
+yamo config set PRIVATE_KEY 0x...
+
+# List current configuration
+yamo config list
+
+# Get a specific value
+yamo config get RPC_URL
+```
+
+### `yamo download-bundle <cid>`
+Downloads a complete YAMO bundle (file + artifacts) from IPFS.
+
+*   `-o, --output <path>`: Output directory path.
+*   `-k, --key <string>`: Decryption key if the bundle is encrypted.
+
+```bash
+yamo download-bundle Qm... -o ./downloads/my-bundle
+```
+
+### `yamo bridge <subcommand>`
+Interact with the YAMO bridge/cluster. Requires `YAMO_BRIDGE_URL` to be set.
+
+*   `kernels`: List connected kernels and their capabilities.
+*   `status`: Show bridge cluster status.
+*   `invoke <skill> --payload <json>`: Invoke a skill via the bridge.
+
+```bash
+yamo bridge status
+yamo bridge kernels
+yamo bridge invoke my-skill -p '{"input": "test"}'
+```
+
 ## 🔒 Encryption
 
 YAMO v1.0 supports optional client-side encryption for IPFS bundles.
@@ -104,4 +142,27 @@ yamo submit task.yamo --ipfs --encrypt --key "my-secret"
 
 # Audit encrypted block
 yamo audit block_001 --key "my-secret"
-```
+```
+
+## 🧪 Testing
+
+Run all tests:
+```bash
+npm test
+```
+
+Run specific test suite:
+```bash
+npm test -- test/hash.test.js
+```
+
+**Test Coverage:**
+- Unit tests: 22 tests (hash, init, validation utilities, format utilities, constants)
+- Integration tests: 8 tests (CLI interface, error handling)
+- E2E tests: 2 tests (basic workflows)
+- Security tests: 13 tests (path traversal protection)
+- Validation tests: 3 tests (blockId format)
+- Auto-fetch tests: 5 tests (previousBlock resolution)
+- Health checks: 2 tests (test suite validation)
+
+**Total: 54+ tests** with 100% pass rate

package/dist/commands/audit.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditCommand = auditCommand;
+const crypto_1 = __importDefault(require("crypto"));
+const config_js_1 = require("../utils/config.js");
+const format_js_1 = require("../utils/format.js");
+const spinner_js_1 = require("../utils/spinner.js");
+const constants_js_1 = require("../utils/constants.js");
+/**
+ * Audit a block's integrity on the blockchain.
+ * @param blockId - Block ID to audit
+ * @param options - Command options
+ * @param deps - Injected dependencies
+ */
+async function auditCommand(blockId, options, deps) {
+    try {
+        const chainSpinner = (0, spinner_js_1.createSpinner)(`Fetching Block ${blockId} from chain...`);
+        let block;
+        try {
+            block = await deps.chainClient.getBlock(blockId);
+            if (!block) {
+                chainSpinner.fail(`[ERROR] Block ${blockId} not found on-chain.`);
+                return;
+            }
+            chainSpinner.succeed(`[DONE] Found on-chain record for ${blockId}`);
+        }
+        catch (e) {
+            chainSpinner.fail(`[FAILED] Failed to fetch block ${blockId}`);
+            throw e;
+        }
+        format_js_1.format.detail('Record Details:');
+        console.log(`  Agent: ${block.agentAddress}`);
+        console.log(`  Hash:  ${block.contentHash}`);
+        console.log(`  IPFS:  ${block.ipfsCID || 'None'}`);
+        if (!block.ipfsCID) {
+            format_js_1.format.warn('No IPFS CID. Cannot perform deep content audit.');
+            return;
+        }
+        const ipfsSpinner = (0, spinner_js_1.createSpinner)('Fetching content from IPFS...');
+        try {
+            const key = options.key || config_js_1.config.encryptionKey;
+            const content = await deps.ipfsClient.download(block.ipfsCID, key);
+            const hash = crypto_1.default.createHash(constants_js_1.CONSTANTS.HASH_ALGORITHM).update(content).digest('hex');
+            const calcHash = constants_js_1.CONSTANTS.HEX_PREFIX + hash;
+            ipfsSpinner.succeed('[DONE] Content retrieved and hashed');
+            console.log(`  Calculated: ${calcHash}`);
+            if (calcHash === block.contentHash) {
+                format_js_1.format.success('✅ INTEGRITY VERIFIED: Content matches chain hash.');
+            }
+            else {
+                format_js_1.format.error('INTEGRITY FAILED: Hash mismatch!');
+                console.log(`  Expected: ${block.contentHash}`);
+                console.log(`  Got:      ${calcHash}`);
+            }
+        }
+        catch (e) {
+            ipfsSpinner.fail('[FAILED] IPFS download or hash failed');
+            throw e;
+        }
+    }
+    catch (error) {
+        (0, format_js_1.handleCommandError)(error);
+    }
+}

package/dist/commands/bridge.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bridgeCommand = bridgeCommand;
+const commander_1 = require("commander");
+const config_js_1 = require("../utils/config.js");
+const format_js_1 = require("../utils/format.js");
+// ── Helpers ────────────────────────────────────────────────────────────────
+function getBridgeBaseUrl() {
+    const url = config_js_1.config.bridgeUrl;
+    if (!url) {
+        throw new Error('Bridge URL not configured. Set YAMO_BRIDGE_URL env var or run: yamo config set YAMO_BRIDGE_URL http://localhost:4001');
+    }
+    // Accept ws:// URLs (bridge WebSocket) and convert to http://
+    return url.replace(/^ws:\/\//, 'http://').replace(/^wss:\/\//, 'https://').replace(/\/$/, '');
+}
+let _rpcId = 0;
+async function bridgeRpc(baseUrl, method, params = {}) {
+    const id = ++_rpcId;
+    const body = JSON.stringify({ jsonrpc: '2.0', method, params, id });
+    const resp = await fetch(`${baseUrl}/rpc`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body,
+    });
+    if (!resp.ok) {
+        throw new Error(`Bridge HTTP ${resp.status}: ${resp.statusText}`);
+    }
+    const json = (await resp.json());
+    if (json.error) {
+        throw new Error(`Bridge RPC error ${json.error.code}: ${json.error.message}`);
+    }
+    return json.result;
+}
+// ── Subcommand handlers ────────────────────────────────────────────────────
+async function kernelsHandler() {
+    try {
+        const baseUrl = getBridgeBaseUrl();
+        const result = (await bridgeRpc(baseUrl, 'kernel.list'));
+        if (result.count === 0) {
+            format_js_1.format.warn('No connected kernels.');
+            return;
+        }
+        format_js_1.format.success(`Connected kernels: ${result.count}`);
+        for (const k of result.kernels) {
+            format_js_1.format.info(`\n  Kernel: ${k.kernel_id}`);
+            format_js_1.format.detail(`    Status:       ${k.status || 'idle'}`);
+            format_js_1.format.detail(`    Last seen:    ${k.last_seen || 'unknown'}`);
+            format_js_1.format.detail(`    Capabilities: ${k.capabilities?.length ? k.capabilities.join(', ') : 'none'}`);
+        }
+    }
+    catch (error) {
+        (0, format_js_1.handleCommandError)(error, 'bridge kernels');
+    }
+}
+async function statusHandler() {
+    try {
+        const baseUrl = getBridgeBaseUrl();
+        const result = (await bridgeRpc(baseUrl, 'cluster.status'));
+        format_js_1.format.success('Bridge cluster status');
+        format_js_1.format.detail(`  Node:              ${result.node}`);
+        format_js_1.format.detail(`  Leader:            ${result.leader ?? 'unknown'}`);
+        format_js_1.format.detail(`  Members:           ${result.members?.join(', ') || 'none'}`);
+        format_js_1.format.detail(`  Connected kernels: ${result.connected_kernels}`);
+    }
+    catch (error) {
+        (0, format_js_1.handleCommandError)(error, 'bridge status');
+    }
+}
+async function invokeHandler(skill, options) {
+    try {
+        const baseUrl = getBridgeBaseUrl();
+        let payload = {};
+        if (options.payload) {
+            try {
+                payload = JSON.parse(options.payload);
+            }
+            catch {
+                // Treat as plain string if not valid JSON
+                payload = options.payload;
+            }
+        }
+        const timeoutMs = options.timeout ? parseInt(options.timeout, 10) : 30_000;
+        format_js_1.format.info(`Invoking skill: ${skill}`);
+        const result = (await bridgeRpc(baseUrl, 'skill.invoke', {
+            skill,
+            payload,
+            timeout_ms: timeoutMs,
+        }));
+        format_js_1.format.success(`Skill invocation complete`);
+        format_js_1.format.detail(`  Skill:      ${result.skill}`);
+        format_js_1.format.detail(`  Handler:    ${result.handler_id}`);
+        format_js_1.format.value(`  Result:     ${JSON.stringify(result.result, null, 2)}`);
+    }
+    catch (error) {
+        (0, format_js_1.handleCommandError)(error, 'bridge invoke');
+    }
+}
+// ── Command builder ────────────────────────────────────────────────────────
+function bridgeCommand() {
+    const bridge = new commander_1.Command('bridge').description('Interact with the YAMO bridge (requires YAMO_BRIDGE_URL)');
+    bridge
+        .command('kernels')
+        .description('List connected kernels and their capabilities')
+        .action(kernelsHandler);
+    bridge
+        .command('status')
+        .description('Show bridge cluster status')
+        .action(statusHandler);
+    bridge
+        .command('invoke <skill>')
+        .description('Invoke a skill via the bridge')
+        .option('-p, --payload <json>', 'JSON payload to pass to the skill handler')
+        .option('-t, --timeout <ms>', 'Timeout in milliseconds', '30000')
+        .action(invokeHandler);
+    return bridge;
+}

package/dist/commands/config.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configCommand = configCommand;
+const storage_js_1 = require("../utils/storage.js");
+const format_js_1 = require("../utils/format.js");
+/**
+ * Handles the 'config' command sub-actions.
+ */
+function configCommand(action, key, value) {
+    try {
+        switch (action) {
+            case 'set': {
+                if (!key || !value) {
+                    throw new Error('Usage: yamo config set <key> <value>');
+                }
+                storage_js_1.storage.set(key, value);
+                format_js_1.format.success(`Set ${key} successfully.`);
+                break;
+            }
+            case 'get': {
+                if (!key) {
+                    throw new Error('Usage: yamo config get <key>');
+                }
+                const val = storage_js_1.storage.get(key);
+                if (val) {
+                    console.log(val);
+                }
+                else {
+                    format_js_1.format.warn(`Key '${key}' not found.`);
+                }
+                break;
+            }
+            case 'list': {
+                const configData = storage_js_1.storage.read();
+                const keys = Object.keys(configData);
+                if (keys.length === 0) {
+                    format_js_1.format.info('No configuration found.');
+                }
+                else {
+                    format_js_1.format.detail('Current Configuration:');
+                    keys.forEach((k) => {
+                        const lowerKey = k.toLowerCase();
+                        const displayValue = lowerKey.includes('key') ||
+                            lowerKey.includes('jwt') ||
+                            lowerKey.includes('secret') ||
+                            lowerKey.includes('pass')
+                            ? '********'
+                            : configData[k];
+                        console.log(`  ${k}: ${displayValue}`);
+                    });
+                }
+                break;
+            }
+            case 'remove': {
+                if (!key) {
+                    throw new Error('Usage: yamo config remove <key>');
+                }
+                storage_js_1.storage.remove(key);
+                format_js_1.format.success(`Removed ${key} successfully.`);
+                break;
+            }
+            default:
+                throw new Error('Invalid action. Use set, get, list, or remove.');
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            format_js_1.format.error(error.message);
+        }
+        else {
+            format_js_1.format.error('Unknown error occurred');
+        }
+    }
+}

package/dist/commands/download-bundle.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadBundleCommand = downloadBundleCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const core_1 = require("@yamo/core");
+const format_js_1 = require("../utils/format.js");
+const constants_js_1 = require("../utils/constants.js");
+dotenv.config();
+/**
+ * Download a bundle from IPFS.
+ * @param cid - IPFS content identifier
+ * @param options - Command options
+ */
+async function downloadBundleCommand(cid, options) {
+    try {
+        format_js_1.format.info(`Downloading bundle ${cid}...`);
+        const ipfs = new core_1.IpfsManager();
+        const key = options.key || process.env.YAMO_ENCRYPTION_KEY;
+        const bundle = await ipfs.downloadBundle(cid, key);
+        // Create output directory
+        const outputDir = options.output.replace('<cid>', cid.substring(0, 8));
+        if (!fs_1.default.existsSync(outputDir)) {
+            fs_1.default.mkdirSync(outputDir, { recursive: true });
+        }
+        // Write block.yamo
+        fs_1.default.writeFileSync(path_1.default.join(outputDir, constants_js_1.CONSTANTS.DEFAULT_FILENAME), bundle.block);
+        format_js_1.format.success(`✓ Downloaded ${constants_js_1.CONSTANTS.DEFAULT_FILENAME}`);
+        // Write metadata
+        if (bundle.metadata) {
+            fs_1.default.writeFileSync(path_1.default.join(outputDir, 'metadata.json'), JSON.stringify(bundle.metadata, null, 2));
+            format_js_1.format.success('✓ Downloaded metadata.json');
+        }
+        // Write artifact files
+        for (const [filename, content] of Object.entries(bundle.files)) {
+            const filePath = path_1.default.join(outputDir, filename);
+            fs_1.default.writeFileSync(filePath, content);
+            format_js_1.format.success(`✓ Downloaded ${filename}`);
+        }
+        format_js_1.format.success(`\nBundle saved to: ${outputDir}`);
+        format_js_1.format.detail(`Files: ${1 + Object.keys(bundle.files).length} total`);
+        if (bundle.metadata?.hasEncryption) {
+            format_js_1.format.warn('🔒 Bundle was decrypted using provided key');
+        }
+    }
+    catch (error) {
+        (0, format_js_1.handleCommandError)(error);
+        format_js_1.format.detail('\nIf the bundle is encrypted, provide --key or set YAMO_ENCRYPTION_KEY');
+    }
+}

package/dist/commands/hash.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashCommand = hashCommand;
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+const constants_js_1 = require("../utils/constants.js");
+const format_js_1 = require("../utils/format.js");
+/**
+ * Calculate SHA256 hash of a file.
+ * @param file - Path to file
+ */
+function hashCommand(file) {
+    try {
+        if (!fs_1.default.existsSync(file)) {
+            throw new Error(`File not found: ${file}`);
+        }
+        const content = fs_1.default.readFileSync(file, 'utf-8').trim();
+        const hash = crypto_1.default.createHash(constants_js_1.CONSTANTS.HASH_ALGORITHM).update(content).digest('hex');
+        const bytes32 = constants_js_1.CONSTANTS.HEX_PREFIX + hash;
+        format_js_1.format.success('Block Content Hash:');
+        format_js_1.format.value(bytes32);
+    }
+    catch (error) {
+        (0, format_js_1.handleCommandError)(error);
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const constants_js_1 = require("../utils/constants.js");
+const format_js_1 = require("../utils/format.js");
+/**
+ * Initialize a new YAMO block template.
+ * @param agentName - Name of the agent
+ * @param options - Command options
+ */
+function initCommand(agentName, options) {
+    try {
+        const template = `
+agent: ${agentName};
+intent: ${options.intent};
+context:
+  platform;yamo_v0.5;
+constraints:
+  - human_readable;true;
+priority: medium;
+output: result.json;
+meta: hypothesis;Initial hypothesis;
+meta: confidence;0.9;
+log: session_start;timestamp;${new Date().toISOString()};
+handoff: User;
+    `.trim();
+        fs_1.default.writeFileSync(constants_js_1.CONSTANTS.DEFAULT_FILENAME, template);
+        format_js_1.format.success(`Created YAMO template: ${chalk_1.default.bold(constants_js_1.CONSTANTS.DEFAULT_FILENAME)}`);
+    }
+    catch (error) {
+        (0, format_js_1.handleCommandError)(error);
+    }
+}

package/dist/commands/submit.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitCommand = submitCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const config_js_1 = require("../utils/config.js");
+const format_js_1 = require("../utils/format.js");
+const spinner_js_1 = require("../utils/spinner.js");
+const validation_js_1 = require("../utils/validation.js");
+const constants_js_1 = require("../utils/constants.js");
+/**
+ * Validate bytes32 hash format
+ */
+function validateBytes32Hash(value, fieldName) {
+    if (!(0, validation_js_1.validateBytes32)(value)) {
+        throw new Error(`${fieldName} must be a valid bytes32 hash (0x + 64 hex chars). ` +
+            `Received: ${value.substring(0, 20)}...` +
+            `\nDo NOT include algorithm prefixes like "sha256:"`);
+    }
+}
+/**
+ * Validate block ID format
+ */
+function validateBlockIdFormat(blockId) {
+    if (!blockId)
+        throw new Error('blockId is required');
+    if (!(0, validation_js_1.validateBlockId)(blockId)) {
+        throw new Error(`blockId must follow format {origin}_{workflow} (e.g., 'claude_chain'). Received: ${blockId}`);
+    }
+}
+/**
+ * Validate encryption key strength
+ */
+async function validateEncryptionKey(key) {
+    const { validatePasswordStrength } = await import('@yamo/core');
+    try {
+        validatePasswordStrength(key);
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : 'Unknown validation error';
+        format_js_1.format.error('Password validation failed:');
+        format_js_1.format.error(errorMessage);
+        format_js_1.format.warn('\nKey requirements:');
+        console.error('  • Minimum 12 characters');
+        console.error('  • Mix of uppercase, lowercase, numbers, symbols');
+        console.error('  • Avoid common patterns (password, 123456, qwerty)');
+        throw e;
+    }
+}
+/**
+ * Prepare files for IPFS upload
+ */
+function prepareIpfsFiles(content, file) {
+    const files = [
+        { name: constants_js_1.CONSTANTS.DEFAULT_FILENAME, content },
+    ];
+    const outputMatch = content.match(/output:\s*([^;]+);/);
+    if (outputMatch) {
+        const artifactName = outputMatch[1].trim();
+        const artifactPath = path_1.default.join(path_1.default.dirname(file), artifactName);
+        const resolvedPath = path_1.default.resolve(artifactPath);
+        const inputDir = path_1.default.resolve(path_1.default.dirname(file));
+        // Security: Validate artifact path
+        (0, validation_js_1.validateArtifactPath)(artifactName, resolvedPath, inputDir);
+        if (fs_1.default.existsSync(resolvedPath)) {
+            format_js_1.format.info(`Bundling output: ${artifactName}`);
+            files.push({ name: artifactName, content: fs_1.default.readFileSync(resolvedPath, 'utf8') });
+        }
+    }
+    return files;
+}
+/**
+ * Resolve previous block hash
+ */
+async function resolvePreviousBlock(chainClient, prev) {
+    if (prev) {
+        validateBytes32Hash(prev, 'previousBlock');
+        return prev;
+    }
+    format_js_1.format.info('[INFO] No previousBlock provided, fetching latest block from chain...');
+    const latestHash = await chainClient.getLatestBlockHash();
+    if (latestHash && latestHash !== constants_js_1.CONSTANTS.GENESIS_HASH) {
+        format_js_1.format.success(`[INFO] Using latest block's contentHash: ${latestHash}`);
+        return latestHash;
+    }
+    format_js_1.format.warn('[INFO] No existing blocks found, using genesis');
+    return constants_js_1.CONSTANTS.GENESIS_HASH;
+}
+/**
+ * Submit a YAMO block to the blockchain.
+ * @param file - Path to YAMO file
+ * @param options - Command options
+ * @param deps - Injected dependencies (Chain and IPFS clients)
+ */
+async function submitCommand(file, options, deps) {
+    try {
+        let blockId = options.id;
+        // Interactive fallback for blockId
+        if (!blockId && process.stdout.isTTY) {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'blockId',
+                    message: 'Enter Unique Block ID (format: {origin}_{workflow}):',
+                    validate: (input) => ((0, validation_js_1.validateBlockId)(input) ? true : 'Invalid format. Use {origin}_{workflow}'),
+                },
+            ]);
+            blockId = answers.blockId;
+        }
+        if (!blockId) {
+            throw new Error('blockId is required. Provide it via --id or interactively.');
+        }
+        // Validate inputs
+        validateBlockIdFormat(blockId);
+        // Validate encryption key if needed
+        let encryptionKey;
+        if (options.encrypt) {
+            let key = options.key || config_js_1.config.encryptionKey;
+            if (!key && process.stdout.isTTY) {
+                const answers = await inquirer_1.default.prompt([
+                    {
+                        type: 'password',
+                        name: 'key',
+                        message: 'Enter Encryption Key:',
+                        mask: '*',
+                    },
+                ]);
+                key = answers.key;
+            }
+            encryptionKey = config_js_1.validateConfig.requireEncryptionKey(key);
+            await validateEncryptionKey(encryptionKey);
+        }
+        // Calculate content hash
+        const content = fs_1.default.readFileSync(file, 'utf8').trim();
+        const hash = crypto_1.default.createHash(constants_js_1.CONSTANTS.HASH_ALGORITHM).update(content).digest('hex');
+        const contentHash = constants_js_1.CONSTANTS.HEX_PREFIX + hash;
+        format_js_1.format.info(`Calculated Hash: ${contentHash}`);
+        // Handle IPFS upload
+        let ipfsCID;
+        if (options.ipfs) {
+            const spinner = (0, spinner_js_1.createSpinner)('Preparing and uploading to IPFS...');
+            try {
+                const files = prepareIpfsFiles(content, file);
+                ipfsCID = await deps.ipfsClient.upload({ content, files, encryptionKey });
+                spinner.succeed(`[DONE] Uploaded to IPFS`);
+                format_js_1.format.info(`IPFS Bundle CID: ${ipfsCID}`);
+            }
+            catch (e) {
+                spinner.fail('[FAILED] IPFS upload failed');
+                throw e;
+            }
+        }
+        // Resolve previous block
+        const resolvedPreviousBlock = await resolvePreviousBlock(deps.chainClient, options.prev);
+        // Submit to blockchain
+        const txSpinner = (0, spinner_js_1.createSpinner)(`Submitting Block ${blockId} to blockchain...`);
+        try {
+            await deps.chainClient.submitBlock(blockId, resolvedPreviousBlock, contentHash, options.consensus, options.ledger, ipfsCID);
+            txSpinner.succeed(`[DONE] Block ${blockId} anchored to chain`);
+        }
+        catch (e) {
+            txSpinner.fail('[FAILED] Blockchain submission failed');
+            throw e;
+        }
+    }
+    catch (error) {
+        (0, format_js_1.handleCommandError)(error);
+    }
+}