@feltdb/core 0.4.12 → 0.4.14

package/dist/cli/commands.js

@@ -4,10 +4,10 @@
 import fs from 'fs';
 import path from 'path';
 import http from 'http';
+import net from 'net';
 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.12';
 function loadProjectEnvironment(file = path.resolve('.env.local')) {
     if (!fs.existsSync(file))
         return;
@@ -24,6 +24,19 @@ function loadProjectEnvironment(file = path.resolve('.env.local')) {
             process.env[key] = value;
     }
 }
+async function availablePort(preferred, host = '127.0.0.1') {
+    for (let port = preferred; port < preferred + 100; port += 1) {
+        const available = await new Promise(resolve => {
+            const server = net.createServer();
+            server.unref();
+            server.once('error', () => resolve(false));
+            server.listen(port, host, () => server.close(() => resolve(true)));
+        });
+        if (available)
+            return port;
+    }
+    throw new Error(`No available port found between ${preferred} and ${preferred + 99}`);
+}
 export async function handleCommand(command, args) {
     switch (command) {
         case 'studio':
@@ -387,35 +400,36 @@ async function handleDev(args) {
     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 requestedAppPort = Number(args.includes('--port') ? args[args.indexOf('--port') + 1] || '5173' : '5173');
+    const requestedStudioPort = Number(args.includes('--studio-port') ? args[args.indexOf('--studio-port') + 1] || '3000' : '3000');
+    const appPort = String(await availablePort(requestedAppPort));
+    const studioPort = String(await availablePort(requestedStudioPort));
+    if (appPort !== String(requestedAppPort))
+        console.log(`Port ${requestedAppPort} is busy; using ${appPort} for the application.`);
+    if (studioPort !== String(requestedStudioPort))
+        console.log(`Port ${requestedStudioPort} is busy; using ${studioPort} for Studio.`);
+    process.env.APP_PORT = appPort;
+    process.env.STUDIO_PORT = studioPort;
+    let selfHostedStarted = false;
     const stopSelfHosted = () => {
-        if (selfHosted && !selfHosted.killed)
-            selfHosted.kill('SIGTERM');
+        if (selfHostedStarted) {
+            spawnSync('docker', ['compose', 'stop', 'feltdb'], { cwd: process.cwd(), stdio: 'ignore' });
+            selfHostedStarted = false;
+        }
     };
     if (config.runtime === 'self-hosted') {
         const docker = spawnSync('docker', ['version'], { stdio: 'ignore' });
         if (docker.status !== 0) {
             throw new Error('Self-hosted development requires Docker Desktop or Docker Engine. Install Docker, start it, and rerun npm run dev.');
         }
-        const containerName = `feltdb-${String(config.namespace || 'app').replace(/[^a-z0-9_.-]/gi, '-').toLowerCase()}`;
-        const image = process.env.FELTDB_IMAGE || `ghcr.io/rkendel1/feltdb:${RELEASE_VERSION}`;
-        const existing = spawnSync('docker', ['rm', '-f', containerName], { stdio: 'ignore' });
-        void existing;
-        console.log(`Starting self-hosted FeltDB server from ${image}...`);
-        selfHosted = spawn('docker', [
-            'run', '--rm', '--name', containerName,
-            '-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}`);
-        });
+        if (!fs.existsSync(path.join(process.cwd(), 'docker-compose.yml'))) {
+            throw new Error('Self-hosted project is missing docker-compose.yml. Regenerate the project with create-feltdb.');
+        }
+        console.log('Building and starting the generated self-hosted FeltDB service...');
+        const compose = spawnSync('docker', ['compose', 'up', '--build', '--detach', 'feltdb'], { cwd: process.cwd(), stdio: 'inherit' });
+        if (compose.status !== 0)
+            throw new Error(`docker compose failed with status ${compose.status ?? 'unknown'}`);
+        selfHostedStarted = true;
         (_c = process.env).VITE_FELTDB_URL || (_c.VITE_FELTDB_URL = 'http://127.0.0.1:7700');
     }
     console.log('FeltDB Dev Server');
@@ -426,7 +440,7 @@ async function handleDev(args) {
     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`);
-    const viteArgs = ['--host', '127.0.0.1', '--port', appPort, ...(open ? ['--open'] : [])];
+    const viteArgs = ['--host', '127.0.0.1', '--port', appPort, '--strictPort', ...(open ? ['--open'] : [])];
     const vite = runLocalVite(viteArgs, false);
     let shuttingDown = false;
     const stopVite = () => { if (!vite.killed)
@@ -699,6 +713,9 @@ async function handleStudio(args) {
     const port = args.includes('--port')
         ? args[args.indexOf('--port') + 1] || '3000'
         : '3000';
+    const host = args.includes('--host')
+        ? args[args.indexOf('--host') + 1] || '127.0.0.1'
+        : '127.0.0.1';
     const open = !args.includes('--no-open');
     const namespace = args.includes('--namespace')
         ? args[args.indexOf('--namespace') + 1] || 'default'
@@ -745,7 +762,7 @@ async function handleStudio(args) {
         response.setHeader('Cache-Control', file.endsWith('index.html') ? 'no-store' : 'public, max-age=31536000, immutable');
         fs.createReadStream(file).pipe(response);
     });
-    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(Number(port), '127.0.0.1', resolve); });
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(Number(port), host, resolve); });
     const parameters = new URLSearchParams({ namespace, runtime });
     if (connectUrl)
         parameters.set('connect', connectUrl);

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

package/dist/create/cli.js

@@ -18,6 +18,7 @@ function parseArgs(args) {
         framework: 'react',
         distributed: true,
         agents: true,
+        webllm: true,
         capabilities: 'search',
     };
     for (let i = 0; i < args.length; i++) {
@@ -46,6 +47,12 @@ function parseArgs(args) {
             case '--no-agents':
                 options.agents = false;
                 break;
+            case '--webllm':
+                options.webllm = true;
+                break;
+            case '--no-webllm':
+                options.webllm = false;
+                break;
             case '--capabilities':
                 options.capabilities = args[++i];
                 break;
@@ -66,6 +73,14 @@ 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 promptForProjectName(defaultName = 'feltdb-app') {
+    while (true) {
+        const value = (await prompt(`What should we name your FeltDB app? (${defaultName}): `)) || defaultName;
+        if (/^[a-z0-9][a-z0-9-]*$/.test(value))
+            return value;
+        console.log('Use lowercase letters, numbers, and dashes (for example: customer-portal).');
+    }
+}
 async function promptSecret(message) {
     if (!process.stdin.isTTY || !process.stdout.isTTY)
         return '';
@@ -161,6 +176,10 @@ async function promptForOptions(defaults) {
         ], defaults.framework),
         distributed: await select('Enable distributed operation?', yesNo, defaults.distributed),
         agents: await select('Include an autonomous agent example?', yesNo, defaults.agents),
+        webllm: await select('Install WebLLM for private natural-language app building?', [
+            { label: 'Yes', value: true, description: 'build FeltDB schemas, capabilities, workflows, and UI locally with AI' },
+            { label: 'No', value: false, description: 'skip the browser model and AI builder' },
+        ], defaults.webllm),
         capabilities: await select('Choose starter capabilities:', [
             { label: 'Search', value: 'search' },
             { label: 'Vector search', value: 'vector' },
@@ -196,7 +215,7 @@ Deployment Target (Explicit):
                           Requires production FeltDB instance or self-host
 
   --self-host             Dedicated FeltDB server with Docker Compose
-                          Best for: Production deployments, multi-user systems
+                          Best for: Staging first, then explicit production promotion
                           Generates Docker Compose with persistent /data volume
 
   --managed               Managed FeltDB runtime
@@ -212,6 +231,8 @@ Options:
   --framework <framework>  Choose framework: react or vanilla (default: react)
   --no-distributed         Disable distributed operation
   --no-agents              Exclude agent examples
+  --webllm                 Include the private natural-language FeltDB app builder (default)
+  --no-webllm              Do not install WebLLM or generate the AI builder
   --capabilities <list>    Choose capabilities: search, vector, or search,vector
   --no-install             Skip npm install
   --no-start               Skip npm run dev
@@ -232,10 +253,12 @@ Learn more: https://github.com/rkendel1/feltdb`);
     }
     // Find project name (first non-flag argument)
     let projectName = 'feltdb-app';
+    let projectNameProvided = false;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (!arg.startsWith('-')) {
             projectName = arg;
+            projectNameProvided = true;
             break;
         }
         // Skip next arg if current arg is a flag that takes a value
@@ -247,10 +270,16 @@ Learn more: https://github.com/rkendel1/feltdb`);
     const shouldInstall = !args.includes('--no-install');
     const shouldStart = !args.includes('--no-start');
     let options = parseArgs(args);
+    if (!projectNameProvided && !shouldAutoYes && process.stdin.isTTY && process.stdout.isTTY) {
+        projectName = await promptForProjectName(projectName);
+    }
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(projectName)) {
+        throw new Error('Application names must use lowercase letters, numbers, and dashes.');
+    }
     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)',
+        'self-hosted': 'Self-hosted with Docker Compose (staging)',
         'managed': 'Managed FeltDB service (hosted persistence, sync, and workloads)',
     };
     if (!runtimeDescriptions[options.runtime]) {
@@ -269,9 +298,11 @@ Learn more: https://github.com/rkendel1/feltdb`);
     console.log(`Framework:     ${options.framework}`);
     console.log(`Distributed:   ${options.distributed ? 'yes' : 'no'}`);
     console.log(`Agents:        ${options.agents ? 'yes' : 'no'}`);
+    console.log(`WebLLM:        ${options.webllm ? 'yes — natural-language app builder' : 'no'}`);
     console.log(`Capabilities:  ${options.capabilities}`);
     console.log('\n═══════════════════════════════════════════════\n');
     const projectDir = path.resolve(process.cwd(), projectName);
+    let projectCreated = false;
     try {
         await createProject({
             projectName,
@@ -281,8 +312,10 @@ Learn more: https://github.com/rkendel1/feltdb`);
             framework: options.framework,
             distributed: options.distributed,
             agents: options.agents,
+            webllm: options.webllm,
             capabilities: options.capabilities,
         });
+        projectCreated = true;
         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: '));
@@ -297,7 +330,7 @@ Learn more: https://github.com/rkendel1/feltdb`);
         console.log('\n✅ FeltDB application created successfully!\n');
         const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
         if (shouldInstall) {
-            console.log('📦 Installing application, Studio, and local AI dependencies...\n');
+            console.log(`📦 Installing application, Studio${options.webllm ? ', and local WebLLM app builder' : ''} dependencies...\n`);
             await run(npm, ['install'], projectDir);
         }
         if (shouldStart) {
@@ -326,7 +359,9 @@ Learn more: https://github.com/rkendel1/feltdb`);
         }
     }
     catch (error) {
-        console.error('❌ Failed to create project:', error);
+        console.error(projectCreated
+            ? `❌ The project was created at ${projectDir}, but setup or startup failed:`
+            : '❌ Failed to create project:', error);
         process.exit(1);
     }
 }

package/dist/create/create.js

@@ -3,8 +3,9 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { randomBytes } from 'crypto';
 import { feltdbPackageRange } from './package-versions.js';
-import { generateDockerCompose, generateDockerfile, generateDockerIgnore, generateDotEnvLocal, } from './docker-compose-generator.js';
+import { generateDockerCompose, generateDockerfile, generateDockerIgnore, generateDotEnvLocal, generateFeltDBDockerfile, generateStudioDockerfile, } from './docker-compose-generator.js';
 export async function createProject(options) {
     const { projectName, templatesDir } = options;
     const projectDir = path.resolve(process.cwd(), projectName);
@@ -29,6 +30,7 @@ export async function createProject(options) {
     const framework = options.framework || 'react';
     const distributed = options.distributed !== false;
     const hasAgents = options.agents !== false;
+    const hasWebLLM = options.webllm !== false;
     const capabilities = options.capabilities || 'search';
     // Create package.json
     const packageJson = {
@@ -65,7 +67,7 @@ export async function createProject(options) {
         packageJson.devDependencies['@types/react'] = '^18.0.0';
         packageJson.devDependencies['@types/react-dom'] = '^18.0.0';
     }
-    if (hasAgents) {
+    if (hasAgents && hasWebLLM) {
         packageJson.dependencies['@feltdb/webllm'] = feltdbPackageRange;
     }
     fs.writeFileSync(path.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
@@ -345,7 +347,7 @@ async function logActivity(event: Omit<ActivityEvent, 'id' | 'timestamp'>): Prom
 `;
     fs.writeFileSync(path.join(srcDir, 'feltdb.ts'), feltdbTs);
     // Create a real local-inference agent for browser projects.
-    if (hasAgents) {
+    if (hasAgents && hasWebLLM) {
         const agentTs = `import { WebLLMProvider } from '@feltdb/webllm';
 import { db, reports } from '../../src/feltdb';
 
@@ -385,15 +387,19 @@ export async function runResearcher(
   }
 
   try {
-    const systemPrompt = \`You are a helpful AI assistant that operates entirely in the browser.
-You help users:
-- Summarize documents concisely
-- Expand and enhance text with more details
-- Generate ideas and suggestions
-- Improve writing clarity and structure
-- Answer questions about document content
+    const systemPrompt = \`You are the private, in-browser FeltDB application builder.
+Turn natural-language product requirements into valid, coherent FeltDB applications. You know the
+Flow DSL and keep collections, references, indexes, capabilities, workflows, triggers, policies,
+agents, and React UI code consistent with one another.
 
-Always be concise and practical. Respect the user's intent.\`;
+Supported field types are text, integer, number, decimal, money, bigint, boolean, datetime, date,
+time, uuid, email, url, phone, json, object, binary, file, geo, enum(...), array<T>, map<T>,
+vector<N>, and ref Collection. Prefer UUID identifiers, explicit references, precise domain types,
+least-privilege capabilities, and policies for every writable collection. Never invent syntax.
+
+When asked to build or change an app, return a short implementation plan followed by complete
+copy-ready feltdb.flow and TypeScript/React code blocks. Preserve the existing app model supplied
+by the user and clearly identify files to create or replace. All inference remains local.\`;
 
     const content = await provider.generate([
       { role: 'system', content: systemPrompt },
@@ -537,10 +543,10 @@ export const capabilities = {
     fs.writeFileSync(path.join(feltdbDir, 'capabilities', 'index.ts'), capabilitiesTs);
     // Create main application file based on framework
     if (framework === 'react') {
-        const agentImport = hasAgents
+        const agentImport = hasAgents && hasWebLLM
             ? "import { runResearcher, summarizeDocument, enhanceDocument, generateIdeas, generateFeltDBFeature, generateReactComponent, generateCapability } from '../feltdb/agents/researcher';"
             : '';
-        const agentState = hasAgents
+        const agentState = hasAgents && hasWebLLM
             ? `  const [prompt, setPrompt] = useState('');
   const [answer, setAnswer] = useState('');
   const [modelStatus, setModelStatus] = useState('Model not loaded');
@@ -548,7 +554,7 @@ export const capabilities = {
   const [selectedDoc, setSelectedDoc] = useState<any | null>(null);
   const [aiMode, setAiMode] = useState<'custom' | 'summarize' | 'enhance' | 'ideas' | 'feltdb' | 'react' | 'capability'>('custom');`
             : '';
-        const agentHandler = hasAgents
+        const agentHandler = hasAgents && hasWebLLM
             ? `
   const handleRunAI = async (mode: 'custom' | 'summarize' | 'enhance' | 'ideas' | 'feltdb' | 'react' | 'capability') => {
     setGenerating(true);
@@ -582,7 +588,7 @@ export const capabilities = {
   };
 `
             : '';
-        const agentMarkup = hasAgents
+        const agentMarkup = hasAgents && hasWebLLM
             ? `
         <section className="researcher">
           <h2>🤖 AI Assistant (Private, Local)</h2>
@@ -1211,7 +1217,8 @@ VITE_FELTDB_MANAGED_NAMESPACE=
 VITE_FELTDB_MANAGED_ENVIRONMENT=production
 
 # Override the default self-hosted container image
-# Example: ghcr.io/rkendel1/feltdb:latest
+# By default the server image is built locally from the bundled source.
+# Example override: your-registry.example/feltdb:staging
 FELTDB_IMAGE=
 
 # Node environment
@@ -1230,8 +1237,12 @@ NODE_ENV=development
         };
         fs.writeFileSync(path.join(projectDir, 'docker-compose.yml'), generateDockerCompose(dockerConfig));
         fs.writeFileSync(path.join(projectDir, 'Dockerfile'), generateDockerfile(dockerConfig, framework));
+        fs.writeFileSync(path.join(projectDir, 'Dockerfile.feltdb'), generateFeltDBDockerfile(dockerConfig));
+        fs.writeFileSync(path.join(projectDir, 'Dockerfile.studio'), generateStudioDockerfile(dockerConfig));
         fs.writeFileSync(path.join(projectDir, '.dockerignore'), generateDockerIgnore());
-        fs.writeFileSync(path.join(projectDir, '.env.docker'), generateDotEnvLocal(dockerConfig));
+        const dockerEnvironment = generateDotEnvLocal(dockerConfig, randomBytes(32).toString('hex'));
+        // Docker Compose loads .env automatically; it is already excluded from git.
+        fs.writeFileSync(path.join(projectDir, '.env'), dockerEnvironment);
     }
     // Create RUNTIME_GUIDE.md
     const runtimeGuide = `# Runtime Configuration Guide
@@ -1483,7 +1494,8 @@ Verify vector database connection and that embeddings are enabled in capabilitie
 - Check out example projects in the templates
 - Join the community Discord for support
 `;
-    fs.writeFileSync(path.join(projectDir, 'RUNTIME_GUIDE.md'), runtimeGuide);
+    // Keep generated projects focused; the runtime guide lives in FeltDB's docs.
+    void runtimeGuide;
     // Create .gitignore
     const gitignore = `node_modules/
 dist/

package/dist/create/docker-compose-generator.js

@@ -2,26 +2,45 @@
  * Docker Compose generator for self-hosted FeltDB deployments
  *
  * Generates:
- * - docker-compose.yml with three services (FeltDB, App, Studio)
- * - Dockerfile for application container
+ * - docker-compose.yml with three locally buildable services
+ * - Dockerfiles for the FeltDB server, application, and Studio
  * - .dockerignore for optimized builds
  * - Environment configuration
  */
 export function generateDockerCompose(config) {
     return `services:
   feltdb:
-    image: \${FELTDB_IMAGE:-ghcr.io/rkendel1/feltdb:${config.version}}
+    image: \${FELTDB_IMAGE:-${config.appName.toLowerCase().replace(/[^a-z0-9]/g, '-')}-feltdb:${config.version}}
+    build:
+      context: .
+      dockerfile: Dockerfile.feltdb
+      args:
+        FELTDB_VERSION: ${config.version}
     container_name: \${COMPOSE_PROJECT_NAME}-feltdb
     environment:
       FELTDB_APP_NAME: \${FELTDB_APP_NAME:-${config.appName}}
       FELTDB_APP_ID: \${FELTDB_APP_ID:-${config.appId}}
       FELTDB_VERSION: \${FELTDB_VERSION:-${config.version}}
+      FELTDB_ENVIRONMENT: \${FELTDB_ENVIRONMENT:-staging}
       FELTDB_PEERS: \${FELTDB_PEERS:-}
-      FELTDB_REPLICATION_PORT: ${config.replicationPort}
+      FELTDB_MASTER_KEY: \${FELTDB_MASTER_KEY}
       NODE_ENV: \${NODE_ENV:-production}
     ports:
       - "\${FELTDB_API_PORT:-${config.port}}:7700"
-      - "\${FELTDB_REPLICATION_PORT:-${config.replicationPort}}:${config.replicationPort}"
+    command:
+      - feltdb-server
+      - --host
+      - 0.0.0.0
+      - --port
+      - "7700"
+      - --namespace
+      - \${FELTDB_APP_ID:-${config.appId}}
+      - --data
+      - /data/feltdb.log
+      - --allow-origin
+      - http://127.0.0.1:\${APP_PORT:-5173}
+      - --allow-origin
+      - http://127.0.0.1:\${STUDIO_PORT:-${config.studioPort}}
     volumes:
       - feltdb_data:/data
       - ./feltdb.flow:/app/feltdb.flow:ro
@@ -69,11 +88,17 @@ export function generateDockerCompose(config) {
       app.feltdb/version: "${config.version}"
 
   studio:
-    image: rkendel1/feltdb-studio:latest
+    image: \${STUDIO_IMAGE:-${config.appName.toLowerCase().replace(/[^a-z0-9]/g, '-')}-studio:${config.version}}
+    build:
+      context: .
+      dockerfile: Dockerfile.studio
+      args:
+        FELTDB_VERSION: ${config.version}
     container_name: \${COMPOSE_PROJECT_NAME}-studio
     environment:
-      FELTDB_API_URL: http://feltdb:7700
-      APP_URL: http://app:3000
+      FELTDB_API_URL: \${FELTDB_PUBLIC_URL:-http://127.0.0.1:${config.port}}
+      APP_URL: \${APP_PUBLIC_URL:-http://127.0.0.1:5173}
+      FELTDB_NAMESPACE: \${FELTDB_APP_ID:-${config.appId}}
     ports:
       - "\${STUDIO_PORT:-${config.studioPort}}:8000"
     depends_on:
@@ -97,6 +122,38 @@ volumes:
       app.feltdb/data: "durable-operations-log"
 `;
 }
+export function generateFeltDBDockerfile(config) {
+    return `# Build the matching FeltDB server without adding engine source to the application.
+FROM rust:1.96-alpine AS builder
+RUN apk add --no-cache nodejs npm pkgconf openssl-dev musl-dev
+WORKDIR /source
+ARG FELTDB_VERSION=${config.version}
+RUN npm install --global "create-feltdb@\${FELTDB_VERSION}" \
+ && cp -R "\$(npm root --global)/create-feltdb/dist/server-source/." /source/
+RUN cargo build -p feltdb-server --release --locked
+
+FROM alpine:3.22
+RUN apk add --no-cache ca-certificates curl tini
+COPY --from=builder /source/target/release/feltdb-server /usr/local/bin/feltdb-server
+RUN adduser -D -u 1000 feltdb && mkdir -p /data && chown feltdb:feltdb /data
+USER feltdb
+EXPOSE 7700
+HEALTHCHECK --interval=10s --timeout=5s --start-period=30s --retries=3 CMD curl -fsS http://127.0.0.1:7700/health || exit 1
+ENTRYPOINT ["/sbin/tini", "--"]
+CMD ["feltdb-server", "--host", "0.0.0.0", "--port", "7700", "--namespace", "${config.appId}", "--data", "/data/feltdb.log", "--allow-origin", "http://127.0.0.1:5173", "--allow-origin", "http://127.0.0.1:${config.studioPort}"]
+`;
+}
+export function generateStudioDockerfile(config) {
+    return `# FeltDB Studio served by the same version as this generated project.
+FROM node:22-alpine
+ARG FELTDB_VERSION=${config.version}
+RUN npm install --global "@feltdb/core@\${FELTDB_VERSION}" && npm cache clean --force
+WORKDIR /project
+COPY feltdb.flow ./feltdb.flow
+EXPOSE 8000
+CMD ["sh", "-c", "feltdb studio --host 0.0.0.0 --port 8000 --namespace \"\${FELTDB_NAMESPACE}\" --runtime self-hosted --connect \"\${FELTDB_API_URL}\" --app-url \"\${APP_URL}\" --no-open"]
+`;
+}
 export function generateDockerfile(config, framework) {
     const buildCommand = 'npm run build';
     return `# FeltDB Application Container
@@ -143,7 +200,7 @@ coverage
 .turbo
 `;
 }
-export function generateDotEnvLocal(config) {
+export function generateDotEnvLocal(config, masterKey = '') {
     return `# Docker Compose Environment
 # Generated by create-feltdb for \${config.appName}
 
@@ -153,9 +210,11 @@ COMPOSE_PROJECT_NAME=${config.appName.toLowerCase().replace(/[^a-z0-9]/g, '-')}
 FELTDB_APP_NAME=${config.appName}
 FELTDB_APP_ID=${config.appId}
 FELTDB_VERSION=${config.version}
+FELTDB_ENVIRONMENT=staging
 FELTDB_API_PORT=${config.port}
 FELTDB_REPLICATION_PORT=${config.replicationPort}
 FELTDB_PEERS=
+FELTDB_MASTER_KEY=${masterKey}
 
 # Application Configuration
 APP_PORT=3000
@@ -164,8 +223,6 @@ FELTDB_API_URL=http://feltdb:7700
 # Studio Configuration
 STUDIO_PORT=${config.studioPort}
 
-# Runtime
-NODE_ENV=production
 `;
 }
 export function generateHealthCheckScript() {

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.4.12';
+export const FELTDB_PACKAGE_VERSION = '0.4.14';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;