@feltdb/core 0.4.5 → 0.4.7

package/README.md

@@ -8,6 +8,15 @@ The main FeltDB API. This package provides a simple, state-first interface for w
 npm install @feltdb/core
 ```
 
+This single package includes the database SDK, WASM runtime, React bindings,
+migration tools, Studio application, `feltdb` CLI, and `create-feltdb`
+scaffolder. The only separate FeltDB package is the optional `@feltdb/webllm`.
+
+```bash
+npx --package @feltdb/core create-feltdb my-app
+npx --package @feltdb/core feltdb studio
+```
+
 React bindings and migration tooling ship as subpath exports of this package:
 
 ```typescript

package/bin/create-feltdb.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+await import('../dist/create/cli.js');

package/bin/feltdb.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+await import('../dist/cli/cli.js');

package/dist/analytics-backend.js

@@ -35,7 +35,7 @@ export class AnalyticsBackend {
         try {
             // Dynamic import of WASM module when available
             // @ts-ignore - WASM module may not exist during development
-            const wasmModule = await import('@feltdb/wasm');
+            const wasmModule = await import('./wasm/feltdb_wasm.js');
             // Create WASM analytics instance
             const wasmAnalytics = new wasmModule.WasmAnalytics();
             // Replace backend with WASM implementation

package/dist/cli/api-client.js

@@ -0,0 +1,236 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as http from 'http';
+export class FeltDBClient {
+    constructor() {
+        this.baseURL = process.env.FELTDB_URL || 'https://api.feltdb.com';
+        this.token = null;
+        this.config = null;
+        this.loadConfig();
+    }
+    loadConfig() {
+        const configPath = path.join(process.env.HOME || '', '.feltdb', 'config.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                const data = fs.readFileSync(configPath, 'utf-8');
+                this.config = JSON.parse(data);
+                this.token = this.config.token || null;
+            }
+            catch (e) {
+                // Config not found or invalid
+            }
+        }
+    }
+    saveConfig(config) {
+        const configDir = path.join(process.env.HOME || '', '.feltdb');
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        fs.writeFileSync(path.join(configDir, 'config.json'), JSON.stringify(config, null, 2));
+        this.config = config;
+        this.token = config.token || null;
+    }
+    async request(options) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.baseURL + options.path);
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (options.token || this.token) {
+                headers['Authorization'] = `Bearer ${options.token || this.token}`;
+            }
+            const body = options.body ? JSON.stringify(options.body) : undefined;
+            const transport = url.protocol === 'http:' ? http : https;
+            const req = transport.request(url, {
+                method: options.method,
+                headers,
+            }, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    if (res.statusCode === 401) {
+                        reject(new Error('Unauthorized. Please run `feltdb login`'));
+                    }
+                    else if (res.statusCode && res.statusCode >= 400) {
+                        try {
+                            const errorData = JSON.parse(data);
+                            reject(new Error(errorData.message || `HTTP ${res.statusCode}`));
+                        }
+                        catch {
+                            reject(new Error(`HTTP ${res.statusCode}`));
+                        }
+                    }
+                    else {
+                        try {
+                            resolve(JSON.parse(data));
+                        }
+                        catch {
+                            resolve(data);
+                        }
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (body)
+                req.write(body);
+            req.end();
+        });
+    }
+    async authenticate(email, password) {
+        const response = await this.request({
+            method: 'POST',
+            path: '/auth/login',
+            body: { email, password },
+        });
+        return response;
+    }
+    async getApplications() {
+        if (!this.config?.account) {
+            throw new Error('No account configured. Run `feltdb login` first.');
+        }
+        return this.request({
+            method: 'GET',
+            path: `/accounts/${this.config.account}/applications`,
+        });
+    }
+    async getApplication(appId) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'GET',
+            path: `/accounts/${this.config.account}/applications/${appId}`,
+        });
+    }
+    async createApplication(data) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'POST',
+            path: `/accounts/${this.config.account}/applications`,
+            body: data,
+        });
+    }
+    async updateApplication(appId, data) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'PUT',
+            path: `/accounts/${this.config.account}/applications/${appId}`,
+            body: data,
+        });
+    }
+    async publishVersion(appId, data) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'POST',
+            path: `/accounts/${this.config.account}/applications/${appId}/versions`,
+            body: data,
+        });
+    }
+    async createDeployment(appId, versionId, topology) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'POST',
+            path: `/accounts/${this.config.account}/applications/${appId}/deployments`,
+            body: { version_id: versionId, topology },
+        });
+    }
+    async planDeployment(input) {
+        return this.request({ method: 'POST', path: '/v1/deployments/plan', body: input });
+    }
+    async certifyDeployment(plan) {
+        return this.request({ method: 'POST', path: '/v1/deployments/certify', body: { plan } });
+    }
+    async executeDeployment(plan) {
+        return this.request({ method: 'POST', path: '/v1/deployments', body: { plan } });
+    }
+    async verifyRelease(releaseId) {
+        return this.request({ method: 'POST', path: `/v1/releases/${encodeURIComponent(releaseId)}/verify` });
+    }
+    async publishRelease(releaseId) {
+        return this.request({ method: 'POST', path: `/v1/releases/${encodeURIComponent(releaseId)}/publish` });
+    }
+    async deploymentOperation(deploymentId, operation, body) {
+        return this.request({ method: 'POST', path: `/v1/deployments/${encodeURIComponent(deploymentId)}/${operation}`, body });
+    }
+    async getDeploymentAudit(deploymentId) {
+        return this.request({ method: 'GET', path: `/v1/deployments/${encodeURIComponent(deploymentId)}/audit` });
+    }
+    async certificationRequest(method, path, body) {
+        if (!path.startsWith('/'))
+            throw new Error('Certification path must begin with /');
+        return this.request({ method, path, body });
+    }
+    async getDeployments(appId) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'GET',
+            path: `/accounts/${this.config.account}/applications/${appId}/deployments`,
+        });
+    }
+    async startExecution(appId, workloadId, input) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'POST',
+            path: `/accounts/${this.config.account}/applications/${appId}/executions`,
+            body: { workload_id: workloadId, input },
+        });
+    }
+    async getExecutions(appId) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'GET',
+            path: `/accounts/${this.config.account}/applications/${appId}/executions`,
+        });
+    }
+    async exportData(appId, format, scope) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'POST',
+            path: `/accounts/${this.config.account}/applications/${appId}/export`,
+            body: { format, scope },
+        });
+    }
+    async createBackup(appId) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'POST',
+            path: `/accounts/${this.config.account}/applications/${appId}/backup`,
+        });
+    }
+    async restoreBackup(appId, backupId) {
+        if (!this.config?.account) {
+            throw new Error('No account configured.');
+        }
+        return this.request({
+            method: 'POST',
+            path: `/accounts/${this.config.account}/applications/${appId}/restore`,
+            body: { backup_id: backupId },
+        });
+    }
+}
+let client = null;
+export function getClient() {
+    if (!client) {
+        client = new FeltDBClient();
+    }
+    return client;
+}

package/dist/cli/cli.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * feltdb CLI
+ *
+ * Developer tools for FeltDB applications
+ */
+import { handleCommand } from './commands.js';
+async function main() {
+    const command = process.argv[2] || 'help';
+    try {
+        await handleCommand(command, process.argv.slice(3));
+    }
+    catch (error) {
+        console.error('Error:', error);
+        process.exit(1);
+    }
+}
+main();