@feltdb/core 0.7.2 → 0.7.3

package/dist/cli/commands.js

@@ -8,7 +8,7 @@ import net from 'net';
 import { createRequire } from 'module';
 import { spawn, spawnSync } from 'child_process';
 import { randomBytes } from 'crypto';
-import { createFeltDB, diffFlowSpec, formatFlowSpec, InvestigationLifecycleManager, parseFlowSpec, planFlowSpecMigration, startLocalDevelopmentAuthority, validateFlowSpec } from '@feltdb/core';
+import { createFeltDB, diffFlowSpec, emptyFlowSpec, formatFlowSpec, InvestigationLifecycleManager, parseFlowSpec, planFlowSpecMigration, startLocalDevelopmentAuthority, validateFlowSpec } from '@feltdb/core';
 import { discoverWorkspace, ensureWorkspaceGitIgnored, generatePairingToken, persistPairingToken, displayWorkspaceStatus, initializeWorkspace, startPairingDiscoveryServer } from './workspace-integration.js';
 import { applicationUrlCandidate, detectApplication, discoverApplicationUrl } from './application.js';
 import { resolveApplicationLifecycle, startManagedApplication, waitForManagedApplication } from './application-lifecycle.js';
@@ -77,6 +77,8 @@ export async function handleCommand(command, args) {
             return handleFlowDiff(args);
         case 'deploy':
             return handleFlowDeploy(args);
+        case 'publish':
+            return handleManagedPublish(args);
         case 'help':
         default:
             return handleHelp();
@@ -231,6 +233,85 @@ async function handleFlowDeploy(args) {
         await db.close();
     }
 }
+async function handleManagedPublish(args) {
+    loadProjectEnvironment();
+    const configPath = path.resolve('feltdb.config.json');
+    if (!fs.existsSync(configPath))
+        throw new Error('feltdb.config.json is required for publish');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    if (config.runtime !== 'managed')
+        throw new Error('feltdb publish requires a managed runtime in feltdb.config.json');
+    const url = process.env.VITE_FELTDB_MANAGED_URL;
+    const token = process.env.VITE_FELTDB_MANAGED_API_KEY;
+    const tenantId = process.env.VITE_FELTDB_MANAGED_TENANT_ID;
+    const applicationId = process.env.VITE_FELTDB_MANAGED_APPLICATION_ID;
+    const namespace = process.env.VITE_FELTDB_MANAGED_NAMESPACE || config.namespace;
+    const environment = process.env.VITE_FELTDB_MANAGED_ENVIRONMENT || 'production';
+    const missing = [
+        ['VITE_FELTDB_MANAGED_URL', url],
+        ['VITE_FELTDB_MANAGED_API_KEY', token],
+        ['VITE_FELTDB_MANAGED_TENANT_ID', tenantId],
+        ['VITE_FELTDB_MANAGED_APPLICATION_ID', applicationId],
+        ['VITE_FELTDB_MANAGED_NAMESPACE', namespace],
+    ].filter(([, value]) => !value).map(([name]) => name);
+    if (missing.length)
+        throw new Error(`Managed publish configuration is incomplete in .env.local: ${missing.join(', ')}`);
+    const file = flowFile(args);
+    const spec = readFlowSpec(file);
+    const diagnostics = validateFlowSpec(spec).filter(value => value.severity === 'error');
+    if (diagnostics.length)
+        throw new Error(diagnostics.map(value => value.message).join('; '));
+    console.log('FeltDB Publish');
+    console.log(`Application: ${spec.app}`);
+    console.log(`Environment: ${environment}`);
+    console.log(`Namespace:   ${namespace}`);
+    console.log(`API:         ${url}`);
+    console.log('✓ Configuration loaded');
+    if (!args.includes('--no-build')) {
+        const manifestPath = path.resolve('package.json');
+        if (!fs.existsSync(manifestPath))
+            throw new Error('package.json is required to build the application');
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        if (!manifest.scripts?.build)
+            throw new Error('package.json must define a build script for managed publish');
+        const build = spawnSync('npm', ['run', 'build'], { cwd: process.cwd(), stdio: 'inherit' });
+        if (build.error)
+            throw build.error;
+        if (build.status !== 0)
+            throw new Error(`Application build failed with exit code ${build.status}`);
+    }
+    console.log('✓ Build completed');
+    console.log('✓ Application validated');
+    const remote = createFeltDB({ namespace, server: { url: url, token: token } });
+    try {
+        const current = await remote.collection('_flow_apps').get(spec.app);
+        const migration = planFlowSpecMigration(current?.spec ?? emptyFlowSpec(spec.app), spec);
+        const destructive = migration.filter(value => value.safety === 'destructive');
+        if (destructive.length && !args.includes('--allow-destructive')) {
+            throw new Error(`Publish contains destructive changes (${destructive.map(value => value.target).join(', ')}); review them and rerun with --allow-destructive`);
+        }
+        const result = await remote.deployFlowSpec(spec, current?.version ?? 0, args.includes('--allow-destructive'));
+        const publishState = {
+            tenantId,
+            applicationId,
+            namespace,
+            environment,
+            deploymentId: `${applicationId}:${environment}:${result.version}`,
+            version: result.version,
+            publishedAt: new Date().toISOString(),
+        };
+        fs.mkdirSync(path.resolve('.feltdb'), { recursive: true });
+        fs.writeFileSync(path.resolve('.feltdb/last-published.json'), `${JSON.stringify(publishState, null, 2)}\n`, { mode: 0o600 });
+        fs.writeFileSync(path.resolve('.feltdb/last-deployed.flow'), formatFlowSpec(spec));
+        console.log('✓ Published');
+        console.log(`Deployment: ${publishState.deploymentId}`);
+        console.log(`Version:    ${result.version}`);
+        console.log('Your app is live.');
+    }
+    finally {
+        await remote.close();
+    }
+}
 async function handleServer(args) {
     const require = createRequire(import.meta.url);
     const packageRoot = path.dirname(require.resolve('@feltdb/core/package.json'));
@@ -1155,9 +1236,13 @@ async function handleDoctor() {
     console.log('\n✅ System healthy\n');
 }
 async function handleStudio(args, onReady) {
+    loadProjectEnvironment();
+    const projectConfigPath = path.resolve('feltdb.config.json');
+    const projectConfig = fs.existsSync(projectConfigPath) ? JSON.parse(fs.readFileSync(projectConfigPath, 'utf8')) : {};
+    const projectIsManaged = projectConfig.runtime === 'managed';
     const connectUrl = args.includes('--connect')
         ? args[args.indexOf('--connect') + 1]
-        : undefined;
+        : projectIsManaged ? process.env.VITE_FELTDB_MANAGED_URL : undefined;
     const port = args.includes('--port')
         ? args[args.indexOf('--port') + 1] || '7701'
         : '7701';
@@ -1167,10 +1252,10 @@ async function handleStudio(args, onReady) {
     const open = !args.includes('--no-open');
     const namespace = args.includes('--namespace')
         ? args[args.indexOf('--namespace') + 1] || 'default'
-        : 'default';
+        : projectIsManaged ? process.env.VITE_FELTDB_MANAGED_NAMESPACE || projectConfig.namespace || 'default' : 'default';
     const runtime = args.includes('--runtime')
         ? args[args.indexOf('--runtime') + 1] || 'browser'
-        : connectUrl ? 'remote' : 'browser';
+        : projectIsManaged ? 'managed' : connectUrl ? 'remote' : 'browser';
     const appUrl = args.includes('--app-url')
         ? args[args.indexOf('--app-url') + 1]
         : undefined;
@@ -1211,7 +1296,15 @@ async function handleStudio(args, onReady) {
             response.setHeader('Content-Type', 'application/json; charset=utf-8');
             response.setHeader('Cache-Control', 'no-store');
             response.setHeader('Pragma', 'no-cache');
-            response.end(JSON.stringify({ token: connectUrl ? process.env.VITE_FELTDB_API_KEY || '' : '', session }));
+            const managedPublish = runtime === 'managed' ? {
+                url: process.env.VITE_FELTDB_MANAGED_URL || connectUrl || '',
+                namespace: process.env.VITE_FELTDB_MANAGED_NAMESPACE || namespace,
+                token: process.env.VITE_FELTDB_MANAGED_API_KEY || process.env.VITE_FELTDB_API_KEY || '',
+                tenantId: process.env.VITE_FELTDB_MANAGED_TENANT_ID || '',
+                applicationId: process.env.VITE_FELTDB_MANAGED_APPLICATION_ID || '',
+                environment: process.env.VITE_FELTDB_MANAGED_ENVIRONMENT || 'production',
+            } : undefined;
+            response.end(JSON.stringify({ token: connectUrl ? process.env.VITE_FELTDB_API_KEY || process.env.VITE_FELTDB_MANAGED_API_KEY || '' : '', managedPublish, session }));
             return;
         }
         if (pathname === '/_feltdb/project') {
@@ -1312,6 +1405,7 @@ Commands:
   validate [file]       Validate an entire FlowSpec application model
   diff [file]           Diff FlowSpec against the last deployed model
   deploy [file]         Validate, version, and deploy FlowSpec
+  publish [file]        Build and publish/update a managed application
   studio               Launch FeltDB Studio (developer interface)
   server               Start self-hosted FeltDB server
   keys                 Manage API keys

package/dist/cli/index.js

@@ -23,7 +23,7 @@ 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.7.2';
+const VERSION = '0.7.3';
 function prompt(question) {
     const rl = readline.createInterface({
         input: process.stdin,

package/dist/create/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.7.2';
+export const FELTDB_PACKAGE_VERSION = '0.7.3';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;