@feltdb/core 0.4.8 → 0.4.9

package/dist/cli/commands.js

@@ -7,7 +7,23 @@ import http from 'http';
 import { createRequire } from 'module';
 import { spawn, spawnSync } from 'child_process';
 import { createFeltDB, diffFlowSpec, formatFlowSpec, parseFlowSpec, planFlowSpecMigration, validateFlowSpec } from '@feltdb/core';
-const RELEASE_VERSION = '0.4.2';
+const RELEASE_VERSION = '0.4.9';
+function loadProjectEnvironment(file = path.resolve('.env.local')) {
+    if (!fs.existsSync(file))
+        return;
+    for (const rawLine of fs.readFileSync(file, 'utf8').split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const separator = line.indexOf('=');
+        if (separator < 1)
+            continue;
+        const key = line.slice(0, separator).trim();
+        const value = line.slice(separator + 1).trim().replace(/^(['"])(.*)\1$/, '$2');
+        if (!(key in process.env))
+            process.env[key] = value;
+    }
+}
 export async function handleCommand(command, args) {
     switch (command) {
         case 'studio':
@@ -351,7 +367,8 @@ function runLocalVite(args, waitForExit) {
     });
 }
 async function handleDev(args) {
-    var _a;
+    var _a, _b, _c;
+    loadProjectEnvironment();
     console.log('🚀 Starting FeltDB development server...\n');
     // Check for feltdb.config.json
     const configPath = path.join(process.cwd(), 'feltdb.config.json');
@@ -360,6 +377,18 @@ async function handleDev(args) {
         process.exit(1);
     }
     const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    if (config.runtime === 'managed') {
+        (_a = process.env).VITE_FELTDB_URL || (_a.VITE_FELTDB_URL = process.env.VITE_FELTDB_MANAGED_URL);
+        (_b = process.env).VITE_FELTDB_API_KEY || (_b.VITE_FELTDB_API_KEY = process.env.VITE_FELTDB_MANAGED_API_KEY);
+    }
+    if (config.runtime === 'managed' && (!process.env.VITE_FELTDB_URL || !process.env.VITE_FELTDB_API_KEY)) {
+        throw new Error('Managed runtime requires VITE_FELTDB_MANAGED_URL and VITE_FELTDB_MANAGED_API_KEY in .env.local. Re-run managed setup or add your managed connection.');
+    }
+    const runtimeNamespace = config.runtime === 'managed'
+        ? process.env.VITE_FELTDB_MANAGED_NAMESPACE || config.namespace
+        : config.namespace;
+    const appPort = args.includes('--port') ? args[args.indexOf('--port') + 1] || '5173' : '5173';
+    const studioPort = args.includes('--studio-port') ? args[args.indexOf('--studio-port') + 1] || '3000' : '3000';
     let selfHosted;
     const stopSelfHosted = () => {
         if (selfHosted && !selfHosted.killed)
@@ -380,20 +409,20 @@ async function handleDev(args) {
             '-p', '7700:8080',
             '-v', `${containerName}-data:/data`,
             image,
+            '--allow-origin', `http://127.0.0.1:${appPort}`,
+            '--allow-origin', `http://127.0.0.1:${studioPort}`,
         ], { stdio: 'inherit' });
         selfHosted.once('exit', code => {
             if (code && code !== 0)
                 console.error(`Self-hosted FeltDB server exited with status ${code}`);
         });
-        (_a = process.env).VITE_FELTDB_URL || (_a.VITE_FELTDB_URL = 'http://127.0.0.1:7700');
+        (_c = process.env).VITE_FELTDB_URL || (_c.VITE_FELTDB_URL = 'http://127.0.0.1:7700');
     }
     console.log('FeltDB Dev Server');
     console.log(`  Namespace: ${config.namespace}`);
     console.log(`  Runtime: ${config.runtime}`);
     console.log(`  Storage: ${config.storage}`);
     console.log(`  Distributed: ${config.distributed}\n`);
-    const appPort = args.includes('--port') ? args[args.indexOf('--port') + 1] || '5173' : '5173';
-    const studioPort = args.includes('--studio-port') ? args[args.indexOf('--studio-port') + 1] || '3000' : '3000';
     const open = !args.includes('--no-open');
     console.log(`Application: http://127.0.0.1:${appPort}`);
     console.log(`Studio:      http://127.0.0.1:${studioPort}\n`);
@@ -407,8 +436,9 @@ async function handleDev(args) {
     process.once('SIGTERM', () => { stopAll(); process.exit(143); });
     await handleStudio([
         '--port', studioPort,
-        '--namespace', config.namespace || 'default',
-        ...(config.runtime === 'self-hosted' ? ['--connect', process.env.VITE_FELTDB_URL] : []),
+        '--namespace', runtimeNamespace || 'default',
+        '--runtime', config.runtime || 'browser',
+        ...((config.runtime === 'self-hosted' || config.runtime === 'managed') && process.env.VITE_FELTDB_URL ? ['--connect', process.env.VITE_FELTDB_URL] : []),
         ...(open ? [] : ['--no-open']),
     ]);
 }
@@ -663,6 +693,9 @@ async function handleStudio(args) {
     const namespace = args.includes('--namespace')
         ? args[args.indexOf('--namespace') + 1] || 'default'
         : 'default';
+    const runtime = args.includes('--runtime')
+        ? args[args.indexOf('--runtime') + 1] || 'browser'
+        : connectUrl ? 'remote' : 'browser';
     if (connectUrl) {
         console.log(`Connecting to: ${connectUrl}`);
         console.log(`Remote Studio: http://localhost:${port}\n`);
@@ -700,7 +733,7 @@ async function handleStudio(args) {
         fs.createReadStream(file).pipe(response);
     });
     await new Promise((resolve, reject) => { server.once('error', reject); server.listen(Number(port), '127.0.0.1', resolve); });
-    const parameters = new URLSearchParams({ namespace });
+    const parameters = new URLSearchParams({ namespace, runtime });
     if (connectUrl)
         parameters.set('connect', connectUrl);
     const query = `?${parameters.toString()}`;

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

package/dist/create/cli.js

@@ -10,6 +10,7 @@ import readline from 'readline';
 import { spawn } from 'child_process';
 import { createProject } from './create.js';
 import { FELTDB_PACKAGE_VERSION } from './package-versions.js';
+import { configureManagedAccount } from './managed-account.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function parseArgs(args) {
     const options = {
@@ -21,6 +22,18 @@ function parseArgs(args) {
     };
     for (let i = 0; i < args.length; i++) {
         switch (args[i]) {
+            case '--browser':
+                options.runtime = 'browser';
+                break;
+            case '--server':
+                options.runtime = 'node';
+                break;
+            case '--self-host':
+                options.runtime = 'self-hosted';
+                break;
+            case '--managed':
+                options.runtime = 'managed';
+                break;
             case '--runtime':
                 options.runtime = args[++i];
                 break;
@@ -49,6 +62,38 @@ function run(command, args, cwd) {
             : reject(new Error(`${command} exited with status ${code ?? 'unknown'}`)));
     });
 }
+async function prompt(message) {
+    const interface_ = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => interface_.question(message, value => { interface_.close(); resolve(value.trim()); }));
+}
+async function promptSecret(message) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return '';
+    const input = process.stdin;
+    const output = process.stdout;
+    const wasRaw = input.isRaw;
+    readline.emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    output.write(message);
+    return new Promise(resolve => {
+        let value = '';
+        const finish = () => { input.off('keypress', onKeypress); input.setRawMode(Boolean(wasRaw)); input.pause(); output.write('\n'); resolve(value); };
+        const onKeypress = (character, key) => {
+            if (key.ctrl && key.name === 'c')
+                process.exit(130);
+            if (key.name === 'return' || key.name === 'enter')
+                return finish();
+            if (key.name === 'backspace') {
+                value = value.slice(0, -1);
+                return;
+            }
+            if (!key.ctrl && !key.meta && character)
+                value += character;
+        };
+        input.on('keypress', onKeypress);
+    });
+}
 async function select(message, choices, initialValue) {
     let selected = Math.max(0, choices.findIndex(choice => choice.value === initialValue));
     const input = process.stdin;
@@ -108,6 +153,7 @@ async function promptForOptions(defaults) {
             { label: 'Browser', value: 'browser', description: 'local-first with durable browser storage' },
             { label: 'Node.js', value: 'node', description: 'application server or worker' },
             { label: 'Self-hosted', value: 'self-hosted', description: 'dedicated FeltDB server' },
+            { label: 'Managed', value: 'managed', description: 'FeltDB-hosted persistence, sync, and workloads' },
         ], defaults.runtime),
         framework: await select('Choose an application framework:', [
             { label: 'React', value: 'react' },
@@ -134,22 +180,35 @@ Usage:
 
 Examples:
   create-feltdb my-app
-  create-feltdb my-app --runtime browser --framework react
-  create-feltdb my-app --yes --no-start
+  create-feltdb my-app --browser
+  create-feltdb my-app --server
+  create-feltdb my-app --self-host
+  create-feltdb my-app --managed
+  create-feltdb my-app --framework react --yes
 
-Runtime Options:
-  --runtime browser       Local-first with durable browser storage (OPFS)
+Deployment Target (Explicit):
+  --browser               Local-first with durable browser storage (IndexedDB)
                           Best for: Client-side apps, offline-first experiences
+                          No server required, full offline capability
 
-  --runtime node          Node.js application server or worker
+  --server                Node.js server runtime with server-side FeltDB authority
                           Best for: Server-side applications, API servers
+                          Requires production FeltDB instance or self-host
 
-  --runtime self-hosted   Dedicated FeltDB server instance
+  --self-host             Dedicated FeltDB server with Docker Compose
                           Best for: Production deployments, multi-user systems
-                          Note: Requires Docker (image: ghcr.io/rkendel1/feltdb)
+                          Generates Docker Compose with persistent /data volume
+
+  --managed               Managed FeltDB runtime
+                          Best for: Production without operating servers
+                          Requires VITE_FELTDB_URL and VITE_FELTDB_API_KEY
 
 Options:
-  --runtime <runtime>      Set application runtime (default: browser)
+  --browser                Explicit: Browser runtime with IndexedDB
+  --server                 Explicit: Node.js server runtime
+  --self-host              Explicit: Self-hosted with Docker Compose
+  --managed                Explicit: Managed FeltDB service
+  --runtime <runtime>      Alternative: Set runtime (browser, node, self-hosted, managed)
   --framework <framework>  Choose framework: react or vanilla (default: react)
   --no-distributed         Disable distributed operation
   --no-agents              Exclude agent examples
@@ -160,11 +219,6 @@ Options:
   -h, --help               Show this help message
   --version                Show version number
 
-Vector Search:
-  Vector search requires additional dependencies and setup. If you choose
-  "Search + vector search" during setup, make sure to review the documentation
-  for configuring your vector database connection.
-
 Environment Variables:
   FELTDB_IMAGE             Override the default self-hosted container image
   NODE_ENV                 Set to 'development' or 'production'
@@ -193,21 +247,31 @@ Learn more: https://github.com/rkendel1/feltdb`);
     const shouldInstall = !args.includes('--no-install');
     const shouldStart = !args.includes('--no-start');
     let options = parseArgs(args);
+    const runtimeDescriptions = {
+        'browser': 'Browser with IndexedDB (local-first, no server)',
+        'node': 'Node.js server (server-side authority)',
+        'self-hosted': 'Self-hosted with Docker Compose (production)',
+        'managed': 'Managed FeltDB service (hosted persistence, sync, and workloads)',
+    };
+    if (!runtimeDescriptions[options.runtime]) {
+        throw new Error(`Unsupported runtime "${options.runtime}". Choose browser, node, self-hosted, or managed.`);
+    }
     console.log('\n✨ Creating FeltDB Application\n');
     if (!shouldAutoYes) {
         options = await promptForOptions(options);
-        const runtimeDescriptions = {
-            'browser': 'Local-first with browser storage',
-            'node': 'Node.js server runtime',
-            'self-hosted': 'Dedicated FeltDB server',
-        };
-        console.log('\nConfiguration:');
-        console.log(`  Runtime:       ${options.runtime} (${runtimeDescriptions[options.runtime]})`);
-        console.log(`  Framework:     ${options.framework}`);
-        console.log(`  Distributed:   ${options.distributed ? 'yes' : 'no'}`);
-        console.log(`  Agents:        ${options.agents ? 'yes' : 'no'}`);
-        console.log(`  Capabilities:  ${options.capabilities}\n`);
     }
+    // Display the deployment target explicitly
+    console.log('\n═══════════════════════════════════════════════');
+    console.log('📦 DEPLOYMENT TARGET');
+    console.log('═══════════════════════════════════════════════');
+    console.log(`\nRuntime:       ${options.runtime.toUpperCase()}`);
+    console.log(`Description:   ${runtimeDescriptions[options.runtime]}`);
+    console.log(`Framework:     ${options.framework}`);
+    console.log(`Distributed:   ${options.distributed ? 'yes' : 'no'}`);
+    console.log(`Agents:        ${options.agents ? 'yes' : 'no'}`);
+    console.log(`Capabilities:  ${options.capabilities}`);
+    console.log('\n═══════════════════════════════════════════════\n');
+    const projectDir = path.resolve(process.cwd(), projectName);
     try {
         await createProject({
             projectName,
@@ -219,8 +283,18 @@ Learn more: https://github.com/rkendel1/feltdb`);
             agents: options.agents,
             capabilities: options.capabilities,
         });
+        if (options.runtime === 'managed') {
+            console.log('\n☁️  Setting up your managed FeltDB account...\n');
+            const email = process.env.FELTDB_MANAGED_EMAIL || (shouldAutoYes ? '' : await prompt('Email: '));
+            const password = process.env.FELTDB_MANAGED_PASSWORD || (shouldAutoYes ? '' : await promptSecret('Password (8+ characters): '));
+            if (!email || password.length < 8) {
+                throw new Error('Managed setup needs an email and an 8+ character password. In non-interactive mode set FELTDB_MANAGED_EMAIL and FELTDB_MANAGED_PASSWORD.');
+            }
+            const managed = await configureManagedAccount({ projectDir, applicationName: projectName, namespace: projectName, email, password });
+            console.log(`✓ Managed application: ${managed.application.name}`);
+            console.log(`✓ Managed environment written to ${projectName}/.env.local`);
+        }
         console.log('\n✅ FeltDB application created successfully!\n');
-        const projectDir = path.resolve(process.cwd(), projectName);
         const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
         if (shouldInstall) {
             console.log('📦 Installing application, Studio, and local AI dependencies...\n');