kynjal-cli 4.0.0 → 4.0.2

package/dist/src/commands/appliance.js

@@ -2,96 +2,41 @@
  * V3 CLI Appliance Command
  * Self-contained RVFA appliance management (build, inspect, verify, extract, run, sign, publish, update)
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { output } from '../output.js';
 import { signCommand, publishCommand, updateAppCommand } from './appliance-advanced.js';
 function fmtSize(bytes) {
     if (bytes < 1024)
-        return bytes + " B";
+        return `${bytes} B`;
     if (bytes < 1024 * 1024)
-        return (bytes / 1024).toFixed(1) + " KB";
+        return `${(bytes / 1024).toFixed(1)} KB`;
     if (bytes < 1024 * 1024 * 1024)
-        return (bytes / (1024 * 1024)).toFixed(1) + " MB";
-    return (bytes / (1024 * 1024 * 1024)).toFixed(2) + " GB";
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
 }
 function errMsg(err) {
     return err instanceof Error ? err.message : String(err);
 }
-var fail = function (msg, detail) {
+const fail = (msg, detail) => {
     output.printError(msg, detail);
     return { success: false, exitCode: 1 };
 };
-function loadModule(path, exportName, label) {
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, import(path)];
-                case 1:
-                    mod = _b.sent();
-                    return [2 /*return*/, mod[exportName]];
-                case 2:
-                    _a = _b.sent();
-                    output.printError("RVFA " + label + " module not found", 'Install with: npm install @claude-flow/appliance');
-                    return [2 /*return*/, null];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function loadModule(path, exportName, label) {
+    try {
+        const mod = await import(path);
+        return mod[exportName];
+    }
+    catch {
+        output.printError(`RVFA ${label} module not found`, 'Install with: npm install @claude-flow/appliance');
+        return null;
+    }
 }
-function requireFile(file) {
-    return __awaiter(this, void 0, Promise, function () {
-        var fs;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, import('fs')];
-                case 1:
-                    fs = _a.sent();
-                    if (!fs.existsSync(file)) {
-                        output.printError("File not found: " + file);
-                        return [2 /*return*/, false];
-                    }
-                    return [2 /*return*/, true];
-            }
-        });
-    });
+async function requireFile(file) {
+    const fs = await import('fs');
+    if (!fs.existsSync(file)) {
+        output.printError(`File not found: ${file}`);
+        return false;
+    }
+    return true;
 }
 function header(title) {
     output.writeln();
@@ -99,440 +44,322 @@ function header(title) {
     output.writeln(output.dim('─'.repeat(50)));
     output.writeln();
 }
-function runSteps(steps, delay) {
-    if (delay === void 0) { delay = 300; }
-    return __awaiter(this, void 0, Promise, function () {
-        var _i, steps_1, step, spinner;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _i = 0, steps_1 = steps;
-                    _a.label = 1;
-                case 1:
-                    if (!(_i < steps_1.length)) return [3 /*break*/, 4];
-                    step = steps_1[_i];
-                    spinner = output.createSpinner({ text: step + '...', spinner: 'dots' });
-                    spinner.start();
-                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, delay); })];
-                case 2:
-                    _a.sent();
-                    spinner.succeed(step);
-                    _a.label = 3;
-                case 3:
-                    _i++;
-                    return [3 /*break*/, 1];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
+async function runSteps(steps, delay = 300) {
+    for (const step of steps) {
+        const spinner = output.createSpinner({ text: step + '...', spinner: 'dots' });
+        spinner.start();
+        await new Promise(r => setTimeout(r, delay));
+        spinner.succeed(step);
+    }
 }
 // BUILD
-var buildCommand = {
+const buildCommand = {
     name: 'build',
     description: 'Build a self-contained ruflo.rvf appliance',
     options: [
-        { name: 'profile', short: 'p', type: 'string', description: 'Build profile: cloud, hybrid, offline', "default": 'cloud' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output file path', "default": 'ruflo.rvf' },
-        { name: 'arch', type: 'string', description: 'Target architecture', "default": 'x86_64' },
+        { name: 'profile', short: 'p', type: 'string', description: 'Build profile: cloud, hybrid, offline', default: 'cloud' },
+        { name: 'output', short: 'o', type: 'string', description: 'Output file path', default: 'ruflo.rvf' },
+        { name: 'arch', type: 'string', description: 'Target architecture', default: 'x86_64' },
         { name: 'models', short: 'm', type: 'array', description: 'Models to include (offline/hybrid)' },
         { name: 'api-keys', type: 'string', description: 'Path to .env file for API key vault' },
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var profile, outputPath, arch, models, apiKeysPath, startTime, RvfaBuilder, steps, builder, result, duration, err_1;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    profile = ctx.flags.profile || 'cloud';
-                    outputPath = ctx.flags.output || 'ruflo.rvf';
-                    arch = ctx.flags.arch || 'x86_64';
-                    models = ctx.flags.models || [];
-                    apiKeysPath = ctx.flags['api-keys'];
-                    header('RVFA Appliance Builder');
-                    output.printInfo("Profile:  " + output.highlight(profile));
-                    output.printInfo("Arch:     " + arch);
-                    output.printInfo("Output:   " + outputPath);
-                    if (models.length > 0)
-                        output.printInfo("Models:   " + models.join(', '));
-                    output.writeln();
-                    startTime = Date.now();
-                    return [4 /*yield*/, loadModule('../appliance/rvfa-builder.js', 'RvfaBuilder', 'builder')];
-                case 1:
-                    RvfaBuilder = _b.sent();
-                    if (!RvfaBuilder)
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    steps = [
-                        'Collecting kernel artifacts', 'Bundling runtime environment',
-                        'Packaging ruflo CLI + MCP tools', 'Compressing sections',
-                        'Computing SHA-256 checksums', 'Writing RVFA container',
-                    ];
-                    if (profile !== 'cloud' && models.length > 0)
-                        steps.splice(3, 0, 'Embedding model weights');
-                    if (apiKeysPath)
-                        steps.splice(steps.length - 1, 0, 'Sealing API key vault');
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 5, , 6]);
-                    builder = new RvfaBuilder({ profile: profile, outputPath: outputPath, arch: arch, models: models, apiKeysPath: apiKeysPath });
-                    return [4 /*yield*/, runSteps(steps)];
-                case 3:
-                    _b.sent();
-                    return [4 /*yield*/, builder.build()];
-                case 4:
-                    result = _b.sent();
-                    duration = ((Date.now() - startTime) / 1000).toFixed(1);
-                    if ((_a = result.sections) === null || _a === void 0 ? void 0 : _a.length) {
-                        output.writeln();
-                        output.printTable({
-                            columns: [
-                                { key: 'id', header: 'Section', width: 16 },
-                                { key: 'size', header: 'Size', width: 12, align: 'right' },
-                            ],
-                            data: result.sections.map(function (s) { return ({ id: s.id, size: fmtSize(s.size) }); })
-                        });
-                    }
-                    output.writeln();
-                    output.printSuccess("Appliance written to " + output.bold(outputPath));
-                    output.printInfo("Total size: " + output.bold(fmtSize(result.totalSize)) + "  Duration: " + duration + "s");
-                    return [2 /*return*/, { success: true, data: result }];
-                case 5:
-                    err_1 = _b.sent();
-                    return [2 /*return*/, fail('Build failed', errMsg(err_1))];
-                case 6: return [2 /*return*/];
+    action: async (ctx) => {
+        const profile = ctx.flags.profile || 'cloud';
+        const outputPath = ctx.flags.output || 'ruflo.rvf';
+        const arch = ctx.flags.arch || 'x86_64';
+        const models = ctx.flags.models || [];
+        const apiKeysPath = ctx.flags['api-keys'];
+        header('RVFA Appliance Builder');
+        output.printInfo(`Profile:  ${output.highlight(profile)}`);
+        output.printInfo(`Arch:     ${arch}`);
+        output.printInfo(`Output:   ${outputPath}`);
+        if (models.length > 0)
+            output.printInfo(`Models:   ${models.join(', ')}`);
+        output.writeln();
+        const startTime = Date.now();
+        const RvfaBuilder = await loadModule('../appliance/rvfa-builder.js', 'RvfaBuilder', 'builder');
+        if (!RvfaBuilder)
+            return { success: false, exitCode: 1 };
+        const steps = [
+            'Collecting kernel artifacts', 'Bundling runtime environment',
+            'Packaging ruflo CLI + MCP tools', 'Compressing sections',
+            'Computing SHA-256 checksums', 'Writing RVFA container',
+        ];
+        if (profile !== 'cloud' && models.length > 0)
+            steps.splice(3, 0, 'Embedding model weights');
+        if (apiKeysPath)
+            steps.splice(steps.length - 1, 0, 'Sealing API key vault');
+        try {
+            const builder = new RvfaBuilder({ profile, outputPath, arch, models, apiKeysPath });
+            await runSteps(steps);
+            const result = await builder.build();
+            const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+            if (result.sections?.length) {
+                output.writeln();
+                output.printTable({
+                    columns: [
+                        { key: 'id', header: 'Section', width: 16 },
+                        { key: 'size', header: 'Size', width: 12, align: 'right' },
+                    ],
+                    data: result.sections.map(s => ({ id: s.id, size: fmtSize(s.size) })),
+                });
             }
-        });
-    }); }
+            output.writeln();
+            output.printSuccess(`Appliance written to ${output.bold(outputPath)}`);
+            output.printInfo(`Total size: ${output.bold(fmtSize(result.totalSize))}  Duration: ${duration}s`);
+            return { success: true, data: result };
+        }
+        catch (err) {
+            return fail('Build failed', errMsg(err));
+        }
+    },
 };
 // INSPECT
-var inspectCommand = {
+const inspectCommand = {
     name: 'inspect',
     description: 'Show RVFA appliance header and section manifest',
     options: [
         { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
         { name: 'json', type: 'boolean', description: 'Output as JSON' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var file, RvfaReader, reader, hdr, _i, _a, _b, label, value, fs, stat, err_2;
-        var _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    file = ctx.flags.file;
-                    if (!file)
-                        return [2 /*return*/, fail('--file is required')];
-                    return [4 /*yield*/, loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format')];
-                case 1:
-                    RvfaReader = _d.sent();
-                    if (!RvfaReader)
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    return [4 /*yield*/, requireFile(file)];
-                case 2:
-                    if (!(_d.sent()))
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    _d.label = 3;
-                case 3:
-                    _d.trys.push([3, 6, , 7]);
-                    reader = new RvfaReader(file);
-                    return [4 /*yield*/, reader.parse()];
-                case 4:
-                    hdr = _d.sent();
-                    if (ctx.flags.json) {
-                        output.printJson(hdr);
-                        return [2 /*return*/, { success: true, data: hdr }];
-                    }
-                    header('RVFA Appliance');
-                    for (_i = 0, _a = [
-                        ['Name', hdr.name || 'ruflo'], ['Version', hdr.version || 'unknown'],
-                        ['Architecture', hdr.arch || 'x86_64'], ['Profile', hdr.profile || 'cloud'],
-                        ['Created', hdr.created || 'unknown'],
-                    ]; _i < _a.length; _i++) {
-                        _b = _a[_i], label = _b[0], value = _b[1];
-                        output.writeln("  " + output.bold(label.padEnd(16)) + value);
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Sections'));
-                    output.writeln(output.dim('─'.repeat(60)));
-                    if ((_c = hdr.sections) === null || _c === void 0 ? void 0 : _c.length) {
-                        output.printTable({
-                            columns: [
-                                { key: 'id', header: 'Section', width: 14 },
-                                { key: 'size', header: 'Packed', width: 12, align: 'right' },
-                                { key: 'original', header: 'Original', width: 12, align: 'right' },
-                                { key: 'compression', header: 'Compression', width: 12 },
-                                { key: 'sha256', header: 'SHA-256', width: 18 },
-                            ],
-                            data: hdr.sections.map(function (s) {
-                                var _a;
-                                return ({
-                                    id: s.id,
-                                    size: fmtSize(s.size),
-                                    original: fmtSize((_a = s.originalSize) !== null && _a !== void 0 ? _a : s.size),
-                                    compression: s.compression || 'none',
-                                    sha256: s.sha256 ? s.sha256.slice(0, 16) + '..' : output.dim('n/a')
-                                });
-                            })
-                        });
-                    }
-                    else {
-                        output.writeln(output.dim('  No sections found'));
-                    }
-                    return [4 /*yield*/, import('fs')];
-                case 5:
-                    fs = _d.sent();
-                    stat = fs.statSync(file);
-                    output.writeln();
-                    output.printInfo("Total file size: " + output.bold(fmtSize(stat.size)));
-                    if (hdr.footerHash) {
-                        output.printInfo("Footer hash:     " + output.dim(hdr.footerHash.slice(0, 32) + '..'));
-                    }
-                    return [2 /*return*/, { success: true, data: hdr }];
-                case 6:
-                    err_2 = _d.sent();
-                    return [2 /*return*/, fail('Failed to inspect appliance', errMsg(err_2))];
-                case 7: return [2 /*return*/];
+    action: async (ctx) => {
+        const file = ctx.flags.file;
+        if (!file)
+            return fail('--file is required');
+        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
+        if (!RvfaReader)
+            return { success: false, exitCode: 1 };
+        if (!(await requireFile(file)))
+            return { success: false, exitCode: 1 };
+        try {
+            const reader = new RvfaReader(file);
+            const hdr = await reader.parse();
+            if (ctx.flags.json) {
+                output.printJson(hdr);
+                return { success: true, data: hdr };
+            }
+            header('RVFA Appliance');
+            for (const [label, value] of [
+                ['Name', hdr.name || 'ruflo'], ['Version', hdr.version || 'unknown'],
+                ['Architecture', hdr.arch || 'x86_64'], ['Profile', hdr.profile || 'cloud'],
+                ['Created', hdr.created || 'unknown'],
+            ]) {
+                output.writeln(`  ${output.bold(label.padEnd(16))}${value}`);
             }
-        });
-    }); }
+            output.writeln();
+            output.writeln(output.bold('Sections'));
+            output.writeln(output.dim('─'.repeat(60)));
+            if (hdr.sections?.length) {
+                output.printTable({
+                    columns: [
+                        { key: 'id', header: 'Section', width: 14 },
+                        { key: 'size', header: 'Packed', width: 12, align: 'right' },
+                        { key: 'original', header: 'Original', width: 12, align: 'right' },
+                        { key: 'compression', header: 'Compression', width: 12 },
+                        { key: 'sha256', header: 'SHA-256', width: 18 },
+                    ],
+                    data: hdr.sections.map((s) => ({
+                        id: s.id,
+                        size: fmtSize(s.size),
+                        original: fmtSize(s.originalSize ?? s.size),
+                        compression: s.compression || 'none',
+                        sha256: s.sha256 ? s.sha256.slice(0, 16) + '..' : output.dim('n/a'),
+                    })),
+                });
+            }
+            else {
+                output.writeln(output.dim('  No sections found'));
+            }
+            const fs = await import('fs');
+            const stat = fs.statSync(file);
+            output.writeln();
+            output.printInfo(`Total file size: ${output.bold(fmtSize(stat.size))}`);
+            if (hdr.footerHash) {
+                output.printInfo(`Footer hash:     ${output.dim(hdr.footerHash.slice(0, 32) + '..')}`);
+            }
+            return { success: true, data: hdr };
+        }
+        catch (err) {
+            return fail('Failed to inspect appliance', errMsg(err));
+        }
+    },
 };
 // VERIFY
-var verifyCommand = {
+const verifyCommand = {
     name: 'verify',
     description: 'Verify appliance integrity and run capability tests',
     options: [
         { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
         { name: 'quick', short: 'q', type: 'boolean', description: 'Quick check (integrity only, skip capability tests)' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var file, quick, RvfaReader, reader, hdr, s1, checksums, allValid, bad, s2, footerOk, capOk, s3, pass, err_3;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    file = ctx.flags.file;
-                    quick = ctx.flags.quick;
-                    if (!file)
-                        return [2 /*return*/, fail('--file is required')];
-                    return [4 /*yield*/, loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format')];
-                case 1:
-                    RvfaReader = _b.sent();
-                    if (!RvfaReader)
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    return [4 /*yield*/, requireFile(file)];
-                case 2:
-                    if (!(_b.sent()))
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    _b.label = 3;
-                case 3:
-                    _b.trys.push([3, 10, , 11]);
-                    header('RVFA Verification');
-                    reader = new RvfaReader(file);
-                    return [4 /*yield*/, reader.parse()];
-                case 4:
-                    hdr = _b.sent();
-                    s1 = output.createSpinner({ text: 'Verifying section checksums...', spinner: 'dots' });
-                    s1.start();
-                    return [4 /*yield*/, reader.verifyChecksums()];
-                case 5:
-                    checksums = _b.sent();
-                    allValid = checksums.every(function (r) { return r.valid; });
-                    if (allValid) {
-                        s1.succeed("Section checksums: " + output.success('PASS') + " (" + checksums.length + " sections)");
-                    }
-                    else {
-                        bad = checksums.filter(function (r) { return !r.valid; });
-                        s1.fail("Section checksums: " + output.error('FAIL') + " (" + bad.length + " corrupted)");
-                        bad.forEach(function (f) { return output.writeln("  " + output.error('X') + " " + f.section); });
-                    }
-                    s2 = output.createSpinner({ text: 'Verifying footer hash...', spinner: 'dots' });
-                    s2.start();
-                    return [4 /*yield*/, reader.verifyFooter()];
-                case 6:
-                    footerOk = _b.sent();
-                    footerOk ? s2.succeed("Footer hash: " + output.success('PASS'))
-                        : s2.fail("Footer hash: " + output.error('FAIL'));
-                    capOk = true;
-                    if (!(!quick && ((_a = hdr.sections) === null || _a === void 0 ? void 0 : _a.find(function (s) { return s.id === 'verify'; })))) return [3 /*break*/, 8];
-                    s3 = output.createSpinner({ text: 'Running capability tests...', spinner: 'dots' });
-                    s3.start();
-                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 500); })];
-                case 7:
-                    _b.sent();
-                    s3.succeed("Capability tests: " + output.success('PASS'));
-                    return [3 /*break*/, 9];
-                case 8:
-                    if (quick) {
-                        output.writeln(output.dim('  Skipped capability tests (--quick)'));
-                    }
-                    _b.label = 9;
-                case 9:
-                    output.writeln();
-                    pass = allValid && footerOk && capOk;
-                    pass ? output.printSuccess('Appliance verification passed')
-                        : output.printError('Appliance verification failed');
-                    return [2 /*return*/, { success: pass, exitCode: pass ? 0 : 1 }];
-                case 10:
-                    err_3 = _b.sent();
-                    return [2 /*return*/, fail('Verification failed', errMsg(err_3))];
-                case 11: return [2 /*return*/];
+    action: async (ctx) => {
+        const file = ctx.flags.file;
+        const quick = ctx.flags.quick;
+        if (!file)
+            return fail('--file is required');
+        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
+        if (!RvfaReader)
+            return { success: false, exitCode: 1 };
+        if (!(await requireFile(file)))
+            return { success: false, exitCode: 1 };
+        try {
+            header('RVFA Verification');
+            const reader = new RvfaReader(file);
+            const hdr = await reader.parse();
+            // Section checksums
+            const s1 = output.createSpinner({ text: 'Verifying section checksums...', spinner: 'dots' });
+            s1.start();
+            const checksums = await reader.verifyChecksums();
+            const allValid = checksums.every(r => r.valid);
+            if (allValid) {
+                s1.succeed(`Section checksums: ${output.success('PASS')} (${checksums.length} sections)`);
+            }
+            else {
+                const bad = checksums.filter(r => !r.valid);
+                s1.fail(`Section checksums: ${output.error('FAIL')} (${bad.length} corrupted)`);
+                bad.forEach(f => output.writeln(`  ${output.error('X')} ${f.section}`));
+            }
+            // Footer hash
+            const s2 = output.createSpinner({ text: 'Verifying footer hash...', spinner: 'dots' });
+            s2.start();
+            const footerOk = await reader.verifyFooter();
+            footerOk ? s2.succeed(`Footer hash: ${output.success('PASS')}`)
+                : s2.fail(`Footer hash: ${output.error('FAIL')}`);
+            // Capability tests
+            let capOk = true;
+            if (!quick && hdr.sections?.find((s) => s.id === 'verify')) {
+                const s3 = output.createSpinner({ text: 'Running capability tests...', spinner: 'dots' });
+                s3.start();
+                await new Promise(r => setTimeout(r, 500));
+                s3.succeed(`Capability tests: ${output.success('PASS')}`);
+            }
+            else if (quick) {
+                output.writeln(output.dim('  Skipped capability tests (--quick)'));
             }
-        });
-    }); }
+            output.writeln();
+            const pass = allValid && footerOk && capOk;
+            pass ? output.printSuccess('Appliance verification passed')
+                : output.printError('Appliance verification failed');
+            return { success: pass, exitCode: pass ? 0 : 1 };
+        }
+        catch (err) {
+            return fail('Verification failed', errMsg(err));
+        }
+    },
 };
 // EXTRACT
-var extractCommand = {
+const extractCommand = {
     name: 'extract',
     description: 'Extract all sections from an RVFA appliance',
     options: [
         { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'output', short: 'o', type: 'string', description: 'Output directory', "default": './rvfa-extracted' },
+        { name: 'output', short: 'o', type: 'string', description: 'Output directory', default: './rvfa-extracted' },
         { name: 'section', short: 's', type: 'string', description: 'Extract specific section only' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var file, outputDir, sectionFilter, RvfaReader, fs, path, reader, hdr, dest, sp, r, results, _i, results_1, r, _a, _b, d, exists, err_4;
-        var _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    file = ctx.flags.file;
-                    outputDir = ctx.flags.output || './rvfa-extracted';
-                    sectionFilter = ctx.flags.section;
-                    if (!file)
-                        return [2 /*return*/, fail('--file is required')];
-                    return [4 /*yield*/, loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format')];
-                case 1:
-                    RvfaReader = _d.sent();
-                    if (!RvfaReader)
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    return [4 /*yield*/, requireFile(file)];
-                case 2:
-                    if (!(_d.sent()))
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    _d.label = 3;
-                case 3:
-                    _d.trys.push([3, 11, , 12]);
-                    return [4 /*yield*/, import('fs')];
-                case 4:
-                    fs = _d.sent();
-                    return [4 /*yield*/, import('path')];
-                case 5:
-                    path = _d.sent();
-                    header('RVFA Extraction');
-                    reader = new RvfaReader(file);
-                    return [4 /*yield*/, reader.parse()];
-                case 6:
-                    hdr = _d.sent();
-                    dest = path.resolve(outputDir);
-                    if (!fs.existsSync(dest))
-                        fs.mkdirSync(dest, { recursive: true });
-                    output.printInfo("Destination: " + dest);
-                    output.writeln();
-                    if (!sectionFilter) return [3 /*break*/, 8];
-                    if (!((_c = hdr.sections) === null || _c === void 0 ? void 0 : _c.find(function (s) { return s.id === sectionFilter; }))) {
-                        output.printError("Section not found: " + sectionFilter);
-                        output.printInfo("Available: " + (hdr.sections || []).map(function (s) { return s.id; }).join(', '));
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    sp = output.createSpinner({ text: "Extracting " + sectionFilter + "...", spinner: 'dots' });
-                    sp.start();
-                    return [4 /*yield*/, reader.extractSection(sectionFilter, dest)];
-                case 7:
-                    r = _d.sent();
-                    sp.succeed(sectionFilter + ": " + fmtSize(r.size));
-                    return [3 /*break*/, 10];
-                case 8: return [4 /*yield*/, reader.extractAll(dest)];
-                case 9:
-                    results = _d.sent();
-                    for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
-                        r = results_1[_i];
-                        output.printSuccess(r.id.padEnd(14) + " " + fmtSize(r.size).padStart(10) + "  -> " + r.path);
-                    }
-                    _d.label = 10;
-                case 10:
-                    output.writeln();
-                    output.printSuccess("Extraction complete: " + dest);
-                    output.writeln(output.dim('  Directory structure:'));
-                    for (_a = 0, _b = ['kernel', 'runtime', 'ruflo', 'models', 'data', 'verify']; _a < _b.length; _a++) {
-                        d = _b[_a];
-                        exists = fs.existsSync(path.join(dest, d));
-                        output.writeln("  " + (exists ? output.success('+') : output.dim('-')) + " " + d + "/");
-                    }
-                    return [2 /*return*/, { success: true }];
-                case 11:
-                    err_4 = _d.sent();
-                    return [2 /*return*/, fail('Extraction failed', errMsg(err_4))];
-                case 12: return [2 /*return*/];
+    action: async (ctx) => {
+        const file = ctx.flags.file;
+        const outputDir = ctx.flags.output || './rvfa-extracted';
+        const sectionFilter = ctx.flags.section;
+        if (!file)
+            return fail('--file is required');
+        const RvfaReader = await loadModule('../appliance/rvfa-format.js', 'RvfaReader', 'format');
+        if (!RvfaReader)
+            return { success: false, exitCode: 1 };
+        if (!(await requireFile(file)))
+            return { success: false, exitCode: 1 };
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            header('RVFA Extraction');
+            const reader = new RvfaReader(file);
+            const hdr = await reader.parse();
+            const dest = path.resolve(outputDir);
+            if (!fs.existsSync(dest))
+                fs.mkdirSync(dest, { recursive: true });
+            output.printInfo(`Destination: ${dest}`);
+            output.writeln();
+            if (sectionFilter) {
+                if (!hdr.sections?.find((s) => s.id === sectionFilter)) {
+                    output.printError(`Section not found: ${sectionFilter}`);
+                    output.printInfo(`Available: ${(hdr.sections || []).map((s) => s.id).join(', ')}`);
+                    return { success: false, exitCode: 1 };
+                }
+                const sp = output.createSpinner({ text: `Extracting ${sectionFilter}...`, spinner: 'dots' });
+                sp.start();
+                const r = await reader.extractSection(sectionFilter, dest);
+                sp.succeed(`${sectionFilter}: ${fmtSize(r.size)}`);
+            }
+            else {
+                const results = await reader.extractAll(dest);
+                for (const r of results) {
+                    output.printSuccess(`${r.id.padEnd(14)} ${fmtSize(r.size).padStart(10)}  -> ${r.path}`);
+                }
+            }
+            output.writeln();
+            output.printSuccess(`Extraction complete: ${dest}`);
+            output.writeln(output.dim('  Directory structure:'));
+            for (const d of ['kernel', 'runtime', 'ruflo', 'models', 'data', 'verify']) {
+                const exists = fs.existsSync(path.join(dest, d));
+                output.writeln(`  ${exists ? output.success('+') : output.dim('-')} ${d}/`);
             }
-        });
-    }); }
+            return { success: true };
+        }
+        catch (err) {
+            return fail('Extraction failed', errMsg(err));
+        }
+    },
 };
 // RUN
-var runCommand = {
+const runCommand = {
     name: 'run',
     description: 'Boot and run an RVFA appliance',
     options: [
         { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'mode', type: 'string', description: 'Run mode: cli, mcp, verify', "default": 'cli' },
-        { name: 'isolation', type: 'string', description: 'Isolation: container, native', "default": 'native' },
+        { name: 'mode', type: 'string', description: 'Run mode: cli, mcp, verify', default: 'cli' },
+        { name: 'isolation', type: 'string', description: 'Isolation: container, native', default: 'native' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var file, mode, isolation, RvfaRunner, runner, result, err_5;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    file = ctx.flags.file;
-                    mode = ctx.flags.mode || 'cli';
-                    isolation = ctx.flags.isolation || 'native';
-                    if (!file)
-                        return [2 /*return*/, fail('--file is required')];
-                    return [4 /*yield*/, loadModule('../appliance/rvfa-runner.js', 'RvfaRunner', 'runner')];
-                case 1:
-                    RvfaRunner = _a.sent();
-                    if (!RvfaRunner)
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    return [4 /*yield*/, requireFile(file)];
-                case 2:
-                    if (!(_a.sent()))
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    _a.label = 3;
-                case 3:
-                    _a.trys.push([3, 6, , 7]);
-                    header('RVFA Appliance Boot');
-                    output.printInfo("File:      " + file);
-                    output.printInfo("Mode:      " + mode);
-                    output.printInfo("Isolation: " + isolation);
-                    output.writeln();
-                    return [4 /*yield*/, runSteps([
-                            'Loading RVFA container', 'Verifying integrity', 'Extracting kernel',
-                            'Initializing runtime',
-                            "Starting " + mode + " interface",
-                        ], 250)];
-                case 4:
-                    _a.sent();
-                    output.writeln();
-                    runner = new RvfaRunner({ file: file, mode: mode, isolation: isolation });
-                    return [4 /*yield*/, runner.boot()];
-                case 5:
-                    result = _a.sent();
-                    if (mode === 'mcp' && result.port)
-                        output.printSuccess("MCP server listening on port " + result.port);
-                    else if (mode === 'verify')
-                        output.printSuccess('Verification complete');
-                    else
-                        output.printSuccess('Appliance is running');
-                    if (result.pid)
-                        output.printInfo("PID: " + result.pid);
-                    return [2 /*return*/, { success: true, data: result }];
-                case 6:
-                    err_5 = _a.sent();
-                    return [2 /*return*/, fail('Boot failed', errMsg(err_5))];
-                case 7: return [2 /*return*/];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const file = ctx.flags.file;
+        const mode = ctx.flags.mode || 'cli';
+        const isolation = ctx.flags.isolation || 'native';
+        if (!file)
+            return fail('--file is required');
+        const RvfaRunner = await loadModule('../appliance/rvfa-runner.js', 'RvfaRunner', 'runner');
+        if (!RvfaRunner)
+            return { success: false, exitCode: 1 };
+        if (!(await requireFile(file)))
+            return { success: false, exitCode: 1 };
+        try {
+            header('RVFA Appliance Boot');
+            output.printInfo(`File:      ${file}`);
+            output.printInfo(`Mode:      ${mode}`);
+            output.printInfo(`Isolation: ${isolation}`);
+            output.writeln();
+            await runSteps([
+                'Loading RVFA container', 'Verifying integrity', 'Extracting kernel',
+                'Initializing runtime', `Starting ${mode} interface`,
+            ], 250);
+            output.writeln();
+            const runner = new RvfaRunner({ file, mode, isolation });
+            const result = await runner.boot();
+            if (mode === 'mcp' && result.port)
+                output.printSuccess(`MCP server listening on port ${result.port}`);
+            else if (mode === 'verify')
+                output.printSuccess('Verification complete');
+            else
+                output.printSuccess('Appliance is running');
+            if (result.pid)
+                output.printInfo(`PID: ${result.pid}`);
+            return { success: true, data: result };
+        }
+        catch (err) {
+            return fail('Boot failed', errMsg(err));
+        }
+    },
 };
 // Main command
-export var applianceCommand = {
+export const applianceCommand = {
     name: 'appliance',
     description: 'Self-contained RVFA appliance management (build, inspect, verify, extract, run)',
     aliases: ['rvfa'],
@@ -547,35 +374,33 @@ export var applianceCommand = {
         { command: 'ruflo appliance publish -f ruflo.rvf', description: 'Publish to IPFS via Pinata' },
         { command: 'ruflo appliance update -f ruflo.rvf -s ruflo -d ./new-ruflo.bin', description: 'Hot-patch a section' },
     ],
-    action: function () { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('Ruflo Appliance (RVFA)'));
-            output.writeln(output.dim('Self-contained deployment format for the full Ruflo platform.'));
-            output.writeln();
-            output.writeln('Subcommands:');
-            output.printList([
-                'build     - Build a self-contained ruflo.rvf appliance',
-                'inspect   - Show appliance header and section manifest',
-                'verify    - Verify appliance integrity and run capability tests',
-                'extract   - Extract all sections from an appliance',
-                'run       - Boot and run an RVFA appliance',
-                'sign      - Sign an appliance with Ed25519 for tamper detection',
-                'publish   - Publish an appliance to IPFS via Pinata',
-                'update    - Hot-patch a section in an appliance',
-            ]);
-            output.writeln();
-            output.writeln('Profiles:');
-            output.printList([
-                output.bold('cloud') + "    - API-only, smallest footprint (~15 MB)",
-                output.bold('hybrid') + "   - API + local fallback models (~500 MB)",
-                output.bold('offline') + "  - Fully air-gapped with bundled models (~4 GB)",
-            ]);
-            output.writeln();
-            output.writeln(output.dim('Use "ruflo appliance <subcommand> --help" for details.'));
-            return [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('Ruflo Appliance (RVFA)'));
+        output.writeln(output.dim('Self-contained deployment format for the full Ruflo platform.'));
+        output.writeln();
+        output.writeln('Subcommands:');
+        output.printList([
+            'build     - Build a self-contained ruflo.rvf appliance',
+            'inspect   - Show appliance header and section manifest',
+            'verify    - Verify appliance integrity and run capability tests',
+            'extract   - Extract all sections from an appliance',
+            'run       - Boot and run an RVFA appliance',
+            'sign      - Sign an appliance with Ed25519 for tamper detection',
+            'publish   - Publish an appliance to IPFS via Pinata',
+            'update    - Hot-patch a section in an appliance',
+        ]);
+        output.writeln();
+        output.writeln('Profiles:');
+        output.printList([
+            `${output.bold('cloud')}    - API-only, smallest footprint (~15 MB)`,
+            `${output.bold('hybrid')}   - API + local fallback models (~500 MB)`,
+            `${output.bold('offline')}  - Fully air-gapped with bundled models (~4 GB)`,
+        ]);
+        output.writeln();
+        output.writeln(output.dim('Use "ruflo appliance <subcommand> --help" for details.'));
+        return { success: true };
+    },
 };
 export default applianceCommand;
 //# sourceMappingURL=appliance.js.map