@feltdb/core 0.4.4 → 0.4.6

package/dist/cli/config.js

@@ -0,0 +1,66 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export function loadFeltDBConfig() {
+    const configPath = path.join(process.cwd(), 'feltdb.json');
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const data = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (e) {
+        throw new Error(`Failed to load feltdb.json: ${e}`);
+    }
+}
+export function saveFeltDBConfig(config) {
+    const configPath = path.join(process.cwd(), 'feltdb.json');
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+export function createDefaultConfig(appName) {
+    return {
+        name: appName,
+        version: '0.1.0',
+        description: 'A FeltDB application',
+        account: 'your-account',
+        model: {
+            collections: [],
+            workloads: [],
+            workflows: [],
+            mesh: {
+                scheduling_strategy: 'capability_based',
+                failover_strategy: 'automatic',
+            },
+        },
+    };
+}
+export function validateModel(model) {
+    const errors = [];
+    if (!Array.isArray(model.collections)) {
+        errors.push('collections must be an array');
+    }
+    if (!Array.isArray(model.workloads)) {
+        errors.push('workloads must be an array');
+    }
+    if (!Array.isArray(model.workflows)) {
+        errors.push('workflows must be an array');
+    }
+    model.collections?.forEach((col, i) => {
+        if (!col.name)
+            errors.push(`Collection ${i} missing name`);
+        if (!col.primaryKey)
+            errors.push(`Collection ${i} missing primaryKey`);
+        if (!Array.isArray(col.fields))
+            errors.push(`Collection ${i} fields must be an array`);
+    });
+    model.workloads?.forEach((wl, i) => {
+        if (!wl.id)
+            errors.push(`Workload ${i} missing id`);
+        if (!wl.name)
+            errors.push(`Workload ${i} missing name`);
+    });
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

package/dist/cli/index.js

@@ -0,0 +1,399 @@
+#!/usr/bin/env node
+/**
+ * FeltDB CLI - Command-line interface for application management
+ *
+ * Usage: feltdb <command> [options]
+ *
+ * Commands:
+ *   login           Authenticate with FeltDB
+ *   init            Initialize a new application
+ *   build           Build application model
+ *   deploy          Deploy application to specified topology
+ *   publish         Publish application version
+ *   status          Check deployment status
+ *   logs            Stream application logs
+ *   execute         Run a workload
+ *   export          Export application data
+ *   backup          Create application backup
+ *   restore         Restore from backup
+ *   list            List applications and deployments
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { getClient } from './api-client.js';
+import { loadFeltDBConfig, createDefaultConfig, validateModel, } from './config.js';
+const VERSION = '0.4.2';
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+function parseArgs(args) {
+    const flags = {};
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i].startsWith('--')) {
+            const key = args[i].slice(2);
+            if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+                flags[key] = args[++i];
+            }
+            else {
+                flags[key] = 'true';
+            }
+        }
+        else {
+            positional.push(args[i]);
+        }
+    }
+    return { flags, positional };
+}
+const commands = {
+    login: {
+        name: 'login',
+        description: 'Authenticate with FeltDB Studio',
+        execute: async (args) => {
+            console.log(`FeltDB CLI v${VERSION}`);
+            console.log('Authenticating...\n');
+            const email = await prompt('Email: ');
+            const password = await prompt('Password: ');
+            try {
+                const client = getClient();
+                const result = await client.authenticate(email, password);
+                client.saveConfig({
+                    account: result.account,
+                    token: result.token,
+                });
+                console.log(`\n✓ Authenticated as ${email}`);
+                console.log(`✓ Account: ${result.account}`);
+            }
+            catch (error) {
+                console.error(`Error: ${error instanceof Error ? error.message : 'Authentication failed'}`);
+                process.exit(1);
+            }
+        },
+    },
+    init: {
+        name: 'init',
+        description: 'Initialize a new FeltDB application',
+        execute: async (args) => {
+            const { positional } = parseArgs(args);
+            const appName = positional[0] || 'my-app';
+            if (fs.existsSync(appName)) {
+                console.error(`Error: Directory ${appName} already exists`);
+                process.exit(1);
+            }
+            console.log(`✓ Initializing application: ${appName}`);
+            const dirs = ['src', 'models', 'workloads', 'workflows'];
+            for (const dir of dirs) {
+                const dirPath = path.join(appName, dir);
+                fs.mkdirSync(dirPath, { recursive: true });
+                console.log(`  Created directory: ${dir}/`);
+            }
+            const config = createDefaultConfig(appName);
+            const configPath = path.join(appName, 'feltdb.json');
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            console.log(`✓ Created feltdb.json`);
+            console.log(`\nNext steps:`);
+            console.log(`  1. cd ${appName}`);
+            console.log(`  2. feltdb build`);
+            console.log(`  3. feltdb deploy --topology local`);
+        },
+    },
+    build: {
+        name: 'build',
+        description: 'Validate and build application model',
+        execute: async (args) => {
+            console.log('Building application model...');
+            const config = loadFeltDBConfig();
+            if (!config) {
+                console.error('Error: feltdb.json not found. Run `feltdb init` first.');
+                process.exit(1);
+            }
+            console.log(`✓ Loaded configuration: ${config.name}`);
+            console.log(`  Collections: ${config.model.collections.length}`);
+            console.log(`  Workloads: ${config.model.workloads.length}`);
+            console.log(`  Workflows: ${config.model.workflows.length}`);
+            const validation = validateModel(config.model);
+            if (!validation.valid) {
+                console.error('✗ Model validation failed:');
+                validation.errors.forEach(err => console.error(`  - ${err}`));
+                process.exit(1);
+            }
+            console.log(`✓ Model is valid`);
+        },
+    },
+    deploy: {
+        name: 'deploy',
+        description: 'Deploy application to specified topology',
+        execute: async (args) => {
+            const { flags, positional } = parseArgs(args);
+            const target = positional[0] || 'all';
+            const provider = flags.provider || flags.topology || (target === 'all' ? 'split' : 'local');
+            const environment = flags.environment || 'production';
+            const profiles = { all: 'all-in-one', studio: 'studio-only', 'control-plane': 'control-plane-only', workers: 'worker-expansion', worker: 'worker-expansion', application: 'application-only', app: 'application-only' };
+            const profile = flags.profile || profiles[target];
+            const config = loadFeltDBConfig();
+            if (!config) {
+                console.error('Error: feltdb.json not found.');
+                process.exit(1);
+            }
+            const allowedTargets = ['all', 'studio', 'control-plane', 'workers', 'worker', 'application', 'app', 'certify'];
+            const allowedProviders = ['local', 'docker', 'fly', 'render', 'vercel', 'split'];
+            if (!allowedTargets.includes(target))
+                throw new Error(`Unknown deployment target: ${target}`);
+            if (!allowedProviders.includes(provider))
+                throw new Error(`Unknown deployment provider: ${provider}`);
+            if (provider === 'vercel' && target !== 'studio' && target !== 'certify') {
+                throw new Error('Vercel can deploy the Studio service only');
+            }
+            const validation = validateModel(config.model);
+            if (!validation.valid)
+                throw new Error(validation.errors.join('; '));
+            const releaseId = flags.release;
+            if (!releaseId)
+                throw new Error('--release <release_id> is required; deployments execute published releases only');
+            const client = getClient();
+            try {
+                if (target === 'all' && provider === 'split') {
+                    const deploymentConfig = config.deployment || {};
+                    const configuration = {
+                        ...(deploymentConfig.configuration || {}),
+                        'control_plane.url': flags['control-plane-url'] || deploymentConfig.configuration?.['control_plane.url'] || 'https://api.feltdb.com',
+                    };
+                    const executeNode = async (node, nodeProvider, nodeProfile) => {
+                        console.log(`→ ${node}: ${nodeProvider}`);
+                        const nodePlan = await client.planDeployment({
+                            release_id: releaseId,
+                            environment,
+                            provider: nodeProvider,
+                            profile: nodeProfile,
+                            rollback_target: flags.rollback,
+                            configuration,
+                            domains: deploymentConfig.domains || [],
+                            secret_references: deploymentConfig.secret_references || [],
+                            scaling_policy: { min_instances: deploymentConfig.min_instances || 1, max_instances: deploymentConfig.max_instances || 1 },
+                        });
+                        const nodeCertification = await client.certifyDeployment(nodePlan);
+                        if (!nodeCertification.valid)
+                            throw new Error(`${node} certification failed: ${nodeCertification.diagnostics.join('; ')}`);
+                        const nodeDeployment = await client.executeDeployment(nodePlan);
+                        if (nodeDeployment.state !== 'ACTIVE')
+                            throw new Error(`${node} did not become ACTIVE: ${nodeDeployment.state}`);
+                        console.log(`✓ ${node} ACTIVE (${nodeDeployment.deployment_id})`);
+                        return nodeDeployment;
+                    };
+                    const controlPlane = await executeNode('control-plane', flags['control-plane-provider'] || 'fly', 'control-plane-only');
+                    const ready = await client.certificationRequest('GET', '/ready');
+                    if (ready.authority !== 'rust' || ready.storage !== 'writable' || ready.authentication !== true) {
+                        throw new Error('deployed control plane failed Rust authority/storage/authentication verification');
+                    }
+                    const studio = await executeNode('studio', flags['studio-provider'] || 'vercel', 'studio-only');
+                    const studioUrl = flags['studio-url'] || configuration['studio.url'];
+                    if (studioUrl) {
+                        const response = await fetch(studioUrl, { redirect: 'follow' });
+                        if (!response.ok)
+                            throw new Error(`Studio verification failed: HTTP ${response.status}`);
+                    }
+                    console.log(`✓ Rust control plane verified: ${controlPlane.deployment_id}`);
+                    console.log(`✓ Studio deployment verified: ${studio.deployment_id}`);
+                    console.log('FELTDB PRODUCTION DEPLOYMENT: PASS');
+                    return;
+                }
+                console.log(`🚀 Deploying ${target} to ${provider}...`);
+                console.log(`  Application: ${config.name}`);
+                console.log(`  Environment: ${environment}`);
+                console.log(`  Profile: ${profile}`);
+                const deploymentConfig = config.deployment || {};
+                const plan = await client.planDeployment({
+                    release_id: releaseId,
+                    environment,
+                    provider,
+                    profile: target === 'certify' ? (flags.profile || 'all-in-one') : profile,
+                    rollback_target: flags.rollback,
+                    configuration: deploymentConfig.configuration || {},
+                    domains: deploymentConfig.domains || [],
+                    secret_references: deploymentConfig.secret_references || [],
+                    scaling_policy: { min_instances: deploymentConfig.min_instances || 1, max_instances: deploymentConfig.max_instances || 1 },
+                });
+                const certification = await client.certifyDeployment(plan);
+                if (!certification.valid)
+                    throw new Error(`Deployment certification failed: ${certification.diagnostics.join('; ')}`);
+                if (target === 'certify') {
+                    if (flags.live !== 'true') {
+                        console.log(`✓ Cloud execution plan certified for ${provider}/${flags.profile || 'all-in-one'}`);
+                        return;
+                    }
+                    const journey = deploymentConfig.certification;
+                    if (!journey?.mutation_path || !journey.read_path)
+                        throw new Error('Live certification requires deployment.certification.mutation_path and read_path');
+                    if (!flags.rollback)
+                        throw new Error('Live certification requires --rollback <previous_release_id>');
+                    const live = await client.executeDeployment(plan);
+                    if (live.state !== 'ACTIVE')
+                        throw new Error(`Deployment did not become ACTIVE: ${live.state}`);
+                    await client.certificationRequest('POST', journey.mutation_path, journey.mutation_body || {});
+                    const beforeRestart = await client.certificationRequest('GET', journey.read_path);
+                    await client.deploymentOperation(live.deployment_id, 'restart');
+                    const afterRestart = await client.certificationRequest('GET', journey.read_path);
+                    if (JSON.stringify(beforeRestart) !== JSON.stringify(afterRestart))
+                        throw new Error('Application state did not survive restart');
+                    await client.deploymentOperation(live.deployment_id, 'rollback');
+                    const audit = await client.getDeploymentAudit(live.deployment_id);
+                    if (!Array.isArray(audit.events) || !audit.events.some((event) => event.operation === 'rollback_health'))
+                        throw new Error('Deployment audit did not record verified rollback');
+                    await client.deploymentOperation(live.deployment_id, 'destroy');
+                    console.log(`✓ Live deployment journey certified and destroyed: ${live.deployment_id}`);
+                    return;
+                }
+                const deployment = await client.executeDeployment(plan);
+                console.log(`✓ Deployment initiated`);
+                console.log(`  ID: ${deployment.deployment_id}`);
+                console.log(`  Status: ${deployment.state}`);
+                console.log(`  Provider: ${provider}`);
+                console.log(`  Target: ${target}`);
+            }
+            catch (error) {
+                console.error(`Error: ${error instanceof Error ? error.message : 'Deployment failed'}`);
+                process.exit(1);
+            }
+        },
+    },
+    deployment: {
+        name: 'deployment',
+        description: 'Run deployment certification against an executable provider',
+        execute: async (args) => {
+            const action = args[0] || 'certify';
+            if (action !== 'certify')
+                throw new Error(`Unknown deployment action: ${action}`);
+            await commands.deploy.execute(['certify', '--live', 'true', ...args.slice(1)]);
+        },
+    },
+    release: {
+        name: 'release',
+        description: 'Certify or publish a release independently of deployment',
+        execute: async (args) => {
+            const action = args[0] || 'certify';
+            if (!['certify', 'publish'].includes(action))
+                throw new Error(`Unknown release action: ${action}`);
+            const config = loadFeltDBConfig();
+            if (!config)
+                throw new Error('feltdb.json not found.');
+            const validation = validateModel(config.model);
+            if (!validation.valid)
+                throw new Error(validation.errors.join('; '));
+            const { flags } = parseArgs(args.slice(1));
+            if (!flags.release)
+                throw new Error('--release <release_id> is required');
+            const client = getClient();
+            if (action === 'certify') {
+                const release = await client.verifyRelease(flags.release);
+                console.log(`✓ Release candidate certified: ${release.manifest.release_id}`);
+            }
+            else {
+                const release = await client.publishRelease(flags.release);
+                console.log(`✓ Release published: ${release.manifest.release_id}`);
+            }
+        },
+    },
+    publish: {
+        name: 'publish',
+        description: 'Publish a version of the application',
+        execute: async (args) => {
+            const { flags } = parseArgs(args);
+            const message = flags.message || 'Release update';
+            const config = loadFeltDBConfig();
+            if (!config) {
+                console.error('Error: feltdb.json not found.');
+                process.exit(1);
+            }
+            const client = getClient();
+            try {
+                console.log('📦 Publishing version...');
+                console.log(`  Building model...`);
+                const app = await client.getApplication(config.name);
+                if (!app) {
+                    console.error(`Error: Application ${config.name} not found`);
+                    process.exit(1);
+                }
+                console.log(`  Creating version snapshot...`);
+                const version = await client.publishVersion(app.id, {
+                    message,
+                    model: config.model,
+                });
+                console.log(`✓ Published version ${version.version}`);
+                console.log(`  ID: ${version.id}`);
+                console.log(`  Ready for deployment`);
+            }
+            catch (error) {
+                console.error(`Error: ${error instanceof Error ? error.message : 'Publishing failed'}`);
+                process.exit(1);
+            }
+        },
+    },
+    help: {
+        name: 'help',
+        description: 'Show help information',
+        execute: async (args) => {
+            console.log(`FeltDB CLI v${VERSION}`);
+            console.log(`\nUsage: feltdb <command> [options]\n`);
+            console.log('Commands:');
+            for (const [key, cmd] of Object.entries(commands)) {
+                console.log(`  ${cmd.name.padEnd(15)} ${cmd.description}`);
+            }
+            console.log('\nOptions:');
+            console.log('  --help             Show this help message');
+            console.log('  --version          Show version');
+            console.log('\nExamples:');
+            console.log('  feltdb login');
+            console.log('  feltdb init my-app');
+            console.log('  feltdb build');
+            console.log('  feltdb release certify');
+            console.log('  feltdb deploy certify --provider docker');
+            console.log('  feltdb deployment certify --provider docker --release <id> --rollback <id>');
+            console.log('  feltdb deploy all --release <id>');
+            console.log('  feltdb publish --message "Release v1.0"');
+        },
+    },
+    version: {
+        name: 'version',
+        description: 'Show version information',
+        execute: async () => {
+            console.log(`FeltDB CLI v${VERSION}`);
+        },
+    },
+};
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        await commands.help.execute([]);
+        return;
+    }
+    const commandName = args[0];
+    const commandArgs = args.slice(1);
+    if (!commands[commandName]) {
+        console.error(`Unknown command: ${commandName}`);
+        console.log(`Run 'feltdb help' for available commands`);
+        process.exit(1);
+    }
+    try {
+        await commands[commandName].execute(commandArgs);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Error: ${error.message}`);
+        }
+        else {
+            console.error('Unknown error occurred');
+        }
+        process.exit(1);
+    }
+}
+main();

package/dist/create/application-identity.js

@@ -0,0 +1,132 @@
+/**
+ * Application identity management
+ *
+ * Handles:
+ * - FELTDB_APP_NAME: Human-readable application name
+ * - FELTDB_APP_ID: UUID-based stable identifier
+ * - FELTDB_VERSION: Semantic versioning
+ * - Version matching between components
+ */
+import crypto from 'crypto';
+import { FELTDB_PACKAGE_VERSION } from './package-versions.js';
+/**
+ * Generate a stable UUID from application name
+ * Ensures same name always produces same ID
+ */
+export function generateAppId(appName) {
+    const hash = crypto
+        .createHash('sha256')
+        .update(appName)
+        .digest('hex');
+    // Convert to UUID v5-like format
+    const uuid = [
+        hash.substring(0, 8),
+        hash.substring(8, 12),
+        '5' + hash.substring(13, 16),
+        ((parseInt(hash.substring(16, 18), 16) & 0x3f) | 0x80).toString(16).padStart(2, '0') +
+            hash.substring(18, 20),
+        hash.substring(20, 32),
+    ].join('-');
+    return uuid;
+}
+/**
+ * Sanitize application name for use in identifiers
+ */
+export function sanitizeAppName(name) {
+    return (name
+        // Replace spaces with hyphens
+        .replace(/\s+/g, '-')
+        // Remove non-alphanumeric except hyphens
+        .replace(/[^a-z0-9-]/gi, '')
+        // Remove leading/trailing hyphens
+        .replace(/^-+|-+$/g, '')
+        // Limit to 50 chars
+        .substring(0, 50)
+        .toLowerCase());
+}
+/**
+ * Get current FeltDB version from package.json
+ */
+export function getCurrentFeltDBVersion() {
+    return FELTDB_PACKAGE_VERSION;
+}
+/**
+ * Create application identity manifest
+ */
+export function createApplicationIdentity(appName, feltdbVersion) {
+    const version = feltdbVersion || getCurrentFeltDBVersion();
+    const sanitized = sanitizeAppName(appName);
+    const appId = generateAppId(sanitized);
+    return {
+        name: sanitized,
+        id: appId,
+        version,
+        createdAt: new Date().toISOString(),
+        components: {
+            app: version,
+            feltdb: version,
+            studio: version,
+        },
+    };
+}
+/**
+ * Generate version manifest for Docker image metadata
+ */
+export function generateVersionLabels(identity) {
+    return {
+        'app.feltdb/app-name': identity.name,
+        'app.feltdb/app-id': identity.id,
+        'app.feltdb/version': identity.version,
+        'app.feltdb/created': identity.createdAt,
+        'app.feltdb/component.app': identity.components.app,
+        'app.feltdb/component.feltdb': identity.components.feltdb,
+        'app.feltdb/component.studio': identity.components.studio,
+    };
+}
+/**
+ * Validate version compatibility
+ */
+export function validateVersionCompatibility(appVersion, feltdbVersion, studioVersion) {
+    const warnings = [];
+    // All components should be same major.minor version for safety
+    const extractMajorMinor = (v) => v.split('.').slice(0, 2).join('.');
+    const appMajorMinor = extractMajorMinor(appVersion);
+    const feltdbMajorMinor = extractMajorMinor(feltdbVersion);
+    const studioMajorMinor = extractMajorMinor(studioVersion);
+    if (appMajorMinor !== feltdbMajorMinor) {
+        warnings.push(`App version ${appVersion} differs from FeltDB ${feltdbVersion}`);
+    }
+    if (feltdbMajorMinor !== studioMajorMinor) {
+        warnings.push(`FeltDB version ${feltdbVersion} differs from Studio ${studioVersion}`);
+    }
+    return {
+        compatible: warnings.length === 0,
+        warnings,
+    };
+}
+/**
+ * Generate .feltdb/identity.json manifest
+ */
+export function generateIdentityManifest(identity) {
+    return JSON.stringify(identity, null, 2);
+}
+/**
+ * Generate environment file with version information
+ */
+export function generateVersionEnv(identity) {
+    return `# Application Identity
+# Generated at: ${identity.createdAt}
+
+FELTDB_APP_NAME=${identity.name}
+FELTDB_APP_ID=${identity.id}
+FELTDB_VERSION=${identity.version}
+
+# Component Versions
+FELTDB_APP_VERSION=${identity.components.app}
+FELTDB_CORE_VERSION=${identity.components.feltdb}
+FELTDB_STUDIO_VERSION=${identity.components.studio}
+
+# Build Info
+FELTDB_BUILT_AT=${new Date().toISOString()}
+`;
+}