monomind 1.9.16 → 1.10.0

package/packages/@monomind/cli/dist/src/commands/appliance-advanced.d.ts

@@ -1,9 +0,0 @@
-/**
- * CLI Appliance Advanced Commands (Phase 3-4)
- * Sign, publish, and hot-patch RVFA appliances.
- */
-import type { Command } from '../types.js';
-export declare const signCommand: Command;
-export declare const publishCommand: Command;
-export declare const updateAppCommand: Command;
-//# sourceMappingURL=appliance-advanced.d.ts.map

package/packages/@monomind/cli/dist/src/commands/appliance-advanced.js

@@ -1,238 +0,0 @@
-/**
- * CLI Appliance Advanced Commands (Phase 3-4)
- * Sign, publish, and hot-patch RVFA appliances.
- */
-import { output } from '../output.js';
-import * as path from 'node:path';
-function fmtSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        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`;
-}
-function errMsg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-function checkRelativePath(userPath) {
-    if (!path.isAbsolute(userPath)) {
-        const resolved = path.resolve(userPath);
-        const rel = path.relative(process.cwd(), resolved);
-        if (rel.startsWith('..')) {
-            return `Relative path '${userPath}' escapes the working directory.`;
-        }
-    }
-    return null;
-}
-const fail = (msg, detail) => {
-    output.printError(msg, detail);
-    return { success: false, exitCode: 1 };
-};
-function hdr(title) {
-    output.writeln();
-    output.writeln(output.bold(title));
-    output.writeln(output.dim('─'.repeat(50)));
-    output.writeln();
-}
-async function requireFile(file) {
-    const fs = await import('fs');
-    if (!fs.existsSync(file)) {
-        output.printError(`File not found: ${file}`);
-        return false;
-    }
-    return true;
-}
-// SIGN
-export const signCommand = {
-    name: 'sign',
-    description: 'Sign an RVFA appliance with Ed25519 for tamper detection',
-    options: [
-        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'key', short: 'k', type: 'string', description: 'Path to Ed25519 private key (PEM)' },
-        { name: 'generate-keys', type: 'boolean', description: 'Generate a new key pair' },
-        { name: 'key-dir', type: 'string', description: 'Directory for key storage', default: '.rvfa-keys' },
-        { name: 'signer', type: 'string', description: 'Publisher name for signature metadata' },
-    ],
-    action: async (ctx) => {
-        const file = ctx.flags.file;
-        const keyPath = ctx.flags.key;
-        const genKeys = ctx.flags['generate-keys'];
-        const keyDir = ctx.flags['key-dir'] || '.rvfa-keys';
-        const signer = ctx.flags.signer;
-        if (!file)
-            return fail('--file is required');
-        try {
-            const signing = await import('../appliance/rvfa-signing.js');
-            if (genKeys) {
-                hdr('Generating Ed25519 Key Pair');
-                const kp = await signing.generateKeyPair();
-                const paths = await signing.saveKeyPair(kp, keyDir);
-                output.printSuccess(`Public key:  ${paths.publicKeyPath}`);
-                output.printSuccess(`Private key: ${paths.privateKeyPath}`);
-                output.printInfo(`Fingerprint: ${kp.fingerprint}`);
-                output.writeln(output.dim('  Keep the private key secure. Share only the public key.'));
-                output.writeln();
-            }
-            if (!(await requireFile(file)))
-                return { success: false, exitCode: 1 };
-            hdr('Signing RVFA Appliance');
-            let privateKey;
-            if (keyPath) {
-                const pathErr = checkRelativePath(keyPath);
-                if (pathErr)
-                    return fail(pathErr);
-                const fs = await import('fs');
-                privateKey = fs.readFileSync(keyPath);
-            }
-            else {
-                const kp = await signing.loadKeyPair(keyDir);
-                privateKey = kp.privateKey;
-            }
-            const s = new signing.RvfaSigner(privateKey);
-            const meta = await s.signAppliance(file, signer);
-            output.printSuccess('Appliance signed successfully');
-            output.printInfo(`Algorithm:   ${meta.algorithm}`);
-            output.printInfo(`Fingerprint: ${meta.publicKeyFingerprint}`);
-            output.printInfo(`Signed at:   ${meta.signedAt}`);
-            if (signer)
-                output.printInfo(`Signed by:   ${signer}`);
-            output.printInfo(`Signature:   ${meta.signature.slice(0, 32)}...`);
-            return { success: true, data: meta };
-        }
-        catch (err) {
-            return fail('Signing failed', errMsg(err));
-        }
-    },
-};
-// PUBLISH
-export const publishCommand = {
-    name: 'publish',
-    description: 'Publish an RVFA appliance to IPFS via Pinata',
-    options: [
-        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'name', short: 'n', type: 'string', description: 'Publication name' },
-        { name: 'description', type: 'string', description: 'Description' },
-    ],
-    action: async (ctx) => {
-        const file = ctx.flags.file;
-        if (!file)
-            return fail('--file is required');
-        if (!(await requireFile(file)))
-            return { success: false, exitCode: 1 };
-        try {
-            const dist = await import('../appliance/rvfa-distribution.js');
-            hdr('Publishing RVFA to IPFS');
-            output.printInfo(`File: ${file}`);
-            output.writeln();
-            const publisher = dist.createPublisher();
-            const result = await publisher.publish(file, {
-                name: ctx.flags.name,
-                description: ctx.flags.description,
-            });
-            output.printSuccess('Published successfully');
-            output.printInfo(`CID:     ${output.bold(result.cid)}`);
-            output.printInfo(`Size:    ${fmtSize(result.size)}`);
-            output.printInfo(`Gateway: ${result.gatewayUrl}`);
-            return { success: true, data: result };
-        }
-        catch (err) {
-            return fail('Publishing failed', errMsg(err));
-        }
-    },
-};
-// UPDATE (hot-patch)
-export const updateAppCommand = {
-    name: 'update',
-    description: 'Hot-patch a section in an RVFA appliance',
-    options: [
-        { name: 'file', short: 'f', type: 'string', description: 'Path to .rvf file', required: true },
-        { name: 'section', short: 's', type: 'string', description: 'Section to patch (e.g. monomind, models)', required: true },
-        { name: 'patch', short: 'p', type: 'string', description: 'Path to .rvfp patch file' },
-        { name: 'data', short: 'd', type: 'string', description: 'Path to new section data (creates patch automatically)' },
-        { name: 'version', type: 'string', description: 'Patch version', default: '0.0.1' },
-        { name: 'no-backup', type: 'boolean', description: 'Skip backup creation' },
-        { name: 'public-key', type: 'string', description: 'Path to public key for patch verification' },
-    ],
-    action: async (ctx) => {
-        const file = ctx.flags.file;
-        const section = ctx.flags.section;
-        const patchPath = ctx.flags.patch;
-        const dataPath = ctx.flags.data;
-        if (!file || !section)
-            return fail('--file and --section are required');
-        if (!patchPath && !dataPath)
-            return fail('Provide --patch (RVFP file) or --data (raw section data)');
-        if (!(await requireFile(file)))
-            return { success: false, exitCode: 1 };
-        try {
-            const dist = await import('../appliance/rvfa-distribution.js');
-            const { RvfaReader } = await import('../appliance/rvfa-format.js');
-            const fs = await import('fs');
-            hdr('RVFA Hot-Patch Update');
-            output.printInfo(`Appliance: ${file}`);
-            output.printInfo(`Section:   ${section}`);
-            output.writeln();
-            let patchBuf;
-            if (patchPath) {
-                const patchPathErr = checkRelativePath(patchPath);
-                if (patchPathErr)
-                    return fail(patchPathErr);
-                if (!(await requireFile(patchPath)))
-                    return { success: false, exitCode: 1 };
-                patchBuf = fs.readFileSync(patchPath);
-                output.printInfo(`Patch file: ${patchPath} (${fmtSize(patchBuf.length)})`);
-            }
-            else {
-                const dataPathErr = checkRelativePath(dataPath);
-                if (dataPathErr)
-                    return fail(dataPathErr);
-                if (!(await requireFile(dataPath)))
-                    return { success: false, exitCode: 1 };
-                const newData = fs.readFileSync(dataPath);
-                const reader = await RvfaReader.fromFile(file);
-                const appHdr = reader.getHeader();
-                output.printInfo(`Creating patch for section "${section}" (${fmtSize(newData.length)} new data)`);
-                patchBuf = await dist.RvfaPatcher.createPatch({
-                    targetName: appHdr.name,
-                    targetVersion: appHdr.appVersion,
-                    sectionId: section,
-                    sectionData: newData,
-                    patchVersion: ctx.flags.version || '0.0.1',
-                    compression: 'gzip',
-                });
-            }
-            let pubKey;
-            if (ctx.flags['public-key']) {
-                const pkPath = ctx.flags['public-key'];
-                const pkPathErr = checkRelativePath(pkPath);
-                if (pkPathErr)
-                    return fail(pkPathErr);
-                if (!(await requireFile(pkPath)))
-                    return { success: false, exitCode: 1 };
-                pubKey = fs.readFileSync(pkPath);
-            }
-            const result = await dist.RvfaPatcher.applyPatch(file, patchBuf, {
-                backup: !ctx.flags['no-backup'],
-                verify: true,
-                publicKey: pubKey,
-            });
-            if (result.success) {
-                output.printSuccess(`Section "${result.patchedSection}" updated successfully`);
-                output.printInfo(`New size: ${fmtSize(result.newSize)}`);
-                if (result.backupPath)
-                    output.printInfo(`Backup:  ${result.backupPath}`);
-            }
-            else {
-                output.printError('Patch failed');
-                result.errors.forEach(e => output.writeln(`  ${output.error('X')} ${e}`));
-            }
-            return { success: result.success, exitCode: result.success ? 0 : 1, data: result };
-        }
-        catch (err) {
-            return fail('Update failed', errMsg(err));
-        }
-    },
-};
-//# sourceMappingURL=appliance-advanced.js.map

package/packages/@monomind/cli/dist/src/commands/appliance.d.ts

@@ -1,8 +0,0 @@
-/**
- * CLI Appliance Command
- * Self-contained RVFA appliance management (build, inspect, verify, extract, run, sign, publish, update)
- */
-import type { Command } from '../types.js';
-export declare const applianceCommand: Command;
-export default applianceCommand;
-//# sourceMappingURL=appliance.d.ts.map

package/packages/@monomind/cli/dist/src/commands/appliance.js

@@ -1,406 +0,0 @@
-/**
- * CLI Appliance Command
- * Self-contained RVFA appliance management (build, inspect, verify, extract, run, sign, publish, update)
- */
-import { output } from '../output.js';
-import { signCommand, publishCommand, updateAppCommand } from './appliance-advanced.js';
-function fmtSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        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`;
-}
-function errMsg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-const fail = (msg, detail) => {
-    output.printError(msg, detail);
-    return { success: false, exitCode: 1 };
-};
-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 @monoes/appliance');
-        return null;
-    }
-}
-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();
-    output.writeln(output.bold(title));
-    output.writeln(output.dim('─'.repeat(50)));
-    output.writeln();
-}
-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
-const buildCommand = {
-    name: 'build',
-    description: 'Build a self-contained monomind.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: 'monomind.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: async (ctx) => {
-        const profile = ctx.flags.profile || 'cloud';
-        const outputPath = ctx.flags.output || 'monomind.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 monomind 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
-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: 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 || 'monomind'], ['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
-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: 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
-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: 'section', short: 's', type: 'string', description: 'Extract specific section only' },
-    ],
-    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', 'monomind', '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
-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' },
-    ],
-    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 const applianceCommand = {
-    name: 'appliance',
-    description: 'Self-contained RVFA appliance management (build, inspect, verify, extract, run)',
-    aliases: ['rvfa'],
-    subcommands: [buildCommand, inspectCommand, verifyCommand, extractCommand, runCommand, signCommand, publishCommand, updateAppCommand],
-    examples: [
-        { command: 'monomind appliance build -p cloud', description: 'Build a cloud appliance' },
-        { command: 'monomind appliance inspect -f monomind.rvf', description: 'Inspect appliance contents' },
-        { command: 'monomind appliance verify -f monomind.rvf', description: 'Verify integrity' },
-        { command: 'monomind appliance extract -f monomind.rvf', description: 'Extract sections' },
-        { command: 'monomind appliance run -f monomind.rvf', description: 'Boot and run appliance' },
-        { command: 'monomind appliance sign -f monomind.rvf --generate-keys', description: 'Generate keys and sign' },
-        { command: 'monomind appliance publish -f monomind.rvf', description: 'Publish to IPFS via Pinata' },
-        { command: 'monomind appliance update -f monomind.rvf -s monomind -d ./new-monomind.bin', description: 'Hot-patch a section' },
-    ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('Monomind Appliance (RVFA)'));
-        output.writeln(output.dim('Self-contained deployment format for the full Monomind platform.'));
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            'build     - Build a self-contained monomind.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 "monomind appliance <subcommand> --help" for details.'));
-        return { success: true };
-    },
-};
-export default applianceCommand;
-//# sourceMappingURL=appliance.js.map

package/packages/@monomind/cli/dist/src/commands/autopilot.d.ts

@@ -1,15 +0,0 @@
-/**
- * CLI Autopilot Command
- * Persistent swarm completion — keeps agents working until ALL tasks are done.
- *
- * ADR-072: Autopilot Integration
- */
-import type { Command } from '../types.js';
-export declare function autopilotCheck(): Promise<{
-    allowStop: boolean;
-    reason: string;
-    continueWith?: string;
-}>;
-export declare const autopilotCommand: Command;
-export default autopilotCommand;
-//# sourceMappingURL=autopilot.d.ts.map