create-feltdb 0.4.4 → 0.4.9

package/README.md

@@ -19,7 +19,8 @@ npx --yes create-feltdb@latest my-app --yes
 
 ### Options
 
-- `--runtime <browser|node|self-hosted>`
+- `--runtime <browser|node|self-hosted|managed>`
+- `--managed` — connect the app and Studio to a managed FeltDB endpoint
 - `--framework <react|vanilla>`
 - `--no-distributed`
 - `--no-agents`

package/dist/application-identity.js

@@ -8,6 +8,7 @@
  * - 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
@@ -47,8 +48,7 @@ export function sanitizeAppName(name) {
  * Get current FeltDB version from package.json
  */
 export function getCurrentFeltDBVersion() {
-    // This would be replaced at build time with the actual version
-    return '0.4.2';
+    return FELTDB_PACKAGE_VERSION;
 }
 /**
  * Create application identity manifest

package/dist/cli.js

@@ -9,6 +9,8 @@ import { fileURLToPath } from 'url';
 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 = {
@@ -20,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;
@@ -48,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;
@@ -107,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' },
@@ -124,11 +171,63 @@ async function promptForOptions(defaults) {
 async function main() {
     const args = process.argv.slice(2);
     if (args.includes('--help') || args.includes('-h')) {
-        console.log(`create-feltdb 0.4.2\n\nUsage: create-feltdb [project-name] [options]\n\nOptions:\n  --runtime <browser|node|self-hosted>\n  --framework <react|vanilla>\n  --no-distributed\n  --no-agents\n  --capabilities <list>\n  --no-install\n  --no-start\n  -y, --yes\n  -h, --help\n  --version`);
+        console.log(`create-feltdb ${FELTDB_PACKAGE_VERSION}
+
+Create a new FeltDB application with one command.
+
+Usage:
+  create-feltdb [project-name] [options]
+
+Examples:
+  create-feltdb my-app
+  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
+
+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
+
+  --server                Node.js server runtime with server-side FeltDB authority
+                          Best for: Server-side applications, API servers
+                          Requires production FeltDB instance or self-host
+
+  --self-host             Dedicated FeltDB server with Docker Compose
+                          Best for: Production deployments, multi-user systems
+                          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:
+  --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
+  --capabilities <list>    Choose capabilities: search, vector, or search,vector
+  --no-install             Skip npm install
+  --no-start               Skip npm run dev
+  -y, --yes                Use all defaults (non-interactive mode)
+  -h, --help               Show this help message
+  --version                Show version number
+
+Environment Variables:
+  FELTDB_IMAGE             Override the default self-hosted container image
+  NODE_ENV                 Set to 'development' or 'production'
+
+Learn more: https://github.com/rkendel1/feltdb`);
         return;
     }
     if (args.includes('--version')) {
-        console.log('0.4.2');
+        console.log(FELTDB_PACKAGE_VERSION);
         return;
     }
     // Find project name (first non-flag argument)
@@ -148,16 +247,31 @@ async function main() {
     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);
-        console.log('\nConfiguration:');
-        console.log(`  Runtime:       ${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,
@@ -169,8 +283,18 @@ async function main() {
             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');