openkbs 0.0.62 → 0.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openkbs",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "description": "OpenKBS - Command Line Interface",
   "main": "src/index.js",
   "scripts": {

package/src/actions.js

@@ -2131,6 +2131,321 @@ async function pulsePublishAction(kbToken, channel, message) {
     }
 }
 
+/**
+ * Deploy from openkbs.json config file
+ * Enables elastic services and deploys functions/site
+ */
+async function elasticDeployAction() {
+    // Find openkbs.json
+    const configPaths = [
+        path.join(process.cwd(), 'openkbs.json'),
+        path.join(process.cwd(), '..', 'openkbs.json')
+    ];
+
+    let configPath = null;
+    for (const p of configPaths) {
+        if (fs.existsSync(p)) {
+            configPath = p;
+            break;
+        }
+    }
+
+    if (!configPath) {
+        return console.red('openkbs.json not found. Create one with your deployment config.');
+    }
+
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const projectDir = path.dirname(configPath);
+    const region = config.region || findRegion() || 'us-east-1';
+
+    console.log(`Deploying ${config.name || 'project'} to ${region}...`);
+
+    // Get KB token
+    const settings = findSettings();
+    if (!settings?.kbId) {
+        return console.red('No kbId found. Run from a directory with settings.json');
+    }
+
+    const res = await fetchKBJWT(settings.kbId);
+    if (!res?.kbToken) {
+        return console.red(`KB ${settings.kbId} not found`);
+    }
+    const kbToken = res.kbToken;
+
+    // Deploy elastic services if configured
+    if (config.elastic) {
+        console.log('\nEnabling Elastic services...');
+        const elasticRes = await makePostRequest(KB_API_URL, {
+            token: kbToken,
+            action: 'deployElastic',
+            elastic: config.elastic
+        });
+
+        if (elasticRes.error) {
+            console.red('Elastic deploy error:', elasticRes.error);
+        } else {
+            if (elasticRes.pulse?.enabled) console.green('  ✓ Pulse enabled');
+            if (elasticRes.postgres?.enabled) console.green('  ✓ Postgres enabled');
+            if (elasticRes.storage?.enabled) console.green('  ✓ Storage enabled');
+            if (elasticRes.storage?.cloudfront) console.green('  ✓ CloudFront configured');
+        }
+    }
+
+    // Deploy functions if configured
+    if (config.functions && config.functions.length > 0) {
+        console.log('\nDeploying functions...');
+        for (const fnName of config.functions) {
+            const fnConfig = typeof fnName === 'object' ? fnName : { name: fnName };
+            const name = fnConfig.name || fnName;
+
+            const args = ['--region', region];
+            if (fnConfig.memory) args.push('--memory', String(fnConfig.memory));
+            if (fnConfig.timeout) args.push('--timeout', String(fnConfig.timeout));
+            if (fnConfig.runtime) args.push('--runtime', fnConfig.runtime);
+            if (fnConfig.handler) args.push('--handler', fnConfig.handler);
+
+            console.log(`  Deploying ${name}...`);
+            await fnDeployAction(kbToken, name, args);
+        }
+    }
+
+    // Deploy site if configured
+    if (config.site) {
+        console.log('\nDeploying site...');
+        const sitePath = path.resolve(projectDir, config.site);
+        await siteDeployAction(kbToken, settings.kbId, sitePath, []);
+    }
+
+    console.green('\nDeploy complete!');
+}
+
+/**
+ * Destroy all resources defined in openkbs.json
+ */
+async function elasticDestroyAction() {
+    // Find openkbs.json
+    const configPaths = [
+        path.join(process.cwd(), 'openkbs.json'),
+        path.join(process.cwd(), '..', 'openkbs.json')
+    ];
+
+    let configPath = null;
+    for (const p of configPaths) {
+        if (fs.existsSync(p)) {
+            configPath = p;
+            break;
+        }
+    }
+
+    if (!configPath) {
+        return console.red('openkbs.json not found.');
+    }
+
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+    console.log(`Destroying ${config.name || 'project'} resources...`);
+    console.yellow('Warning: This will permanently delete all resources!\n');
+
+    // Get KB token
+    const settings = findSettings();
+    if (!settings?.kbId) {
+        return console.red('No kbId found. Run from a directory with settings.json');
+    }
+
+    const res = await fetchKBJWT(settings.kbId);
+    if (!res?.kbToken) {
+        return console.red(`KB ${settings.kbId} not found`);
+    }
+    const kbToken = res.kbToken;
+
+    // Delete functions
+    if (config.functions && config.functions.length > 0) {
+        console.log('Deleting functions...');
+        for (const fnName of config.functions) {
+            const name = typeof fnName === 'object' ? fnName.name : fnName;
+            try {
+                await fnDeleteAction(kbToken, name);
+                console.green(`  ✓ Deleted ${name}`);
+            } catch (e) {
+                console.yellow(`  ⚠ ${name}: ${e.message}`);
+            }
+        }
+    }
+
+    // Disable elastic services
+    if (config.elastic) {
+        console.log('\nDisabling Elastic services...');
+
+        if (config.elastic.storage) {
+            try {
+                await makePostRequest(KB_API_URL, {
+                    token: kbToken,
+                    action: 'deleteElasticStorage',
+                    force: true
+                });
+                console.green('  ✓ Storage disabled');
+            } catch (e) {
+                console.yellow(`  ⚠ Storage: ${e.message}`);
+            }
+        }
+
+        if (config.elastic.postgres) {
+            try {
+                await makePostRequest(KB_API_URL, {
+                    token: kbToken,
+                    action: 'deleteElasticPostgres'
+                });
+                console.green('  ✓ Postgres disabled');
+            } catch (e) {
+                console.yellow(`  ⚠ Postgres: ${e.message}`);
+            }
+        }
+
+        if (config.elastic.pulse) {
+            try {
+                await makePostRequest(KB_API_URL, {
+                    token: kbToken,
+                    action: 'disableElasticPulse'
+                });
+                console.green('  ✓ Pulse disabled');
+            } catch (e) {
+                console.yellow(`  ⚠ Pulse: ${e.message}`);
+            }
+        }
+    }
+
+    console.green('\nDestroy complete!');
+}
+
+/**
+ * Show status of all resources defined in openkbs.json
+ */
+async function elasticStatusAction() {
+    // Find openkbs.json
+    const configPaths = [
+        path.join(process.cwd(), 'openkbs.json'),
+        path.join(process.cwd(), '..', 'openkbs.json')
+    ];
+
+    let configPath = null;
+    for (const p of configPaths) {
+        if (fs.existsSync(p)) {
+            configPath = p;
+            break;
+        }
+    }
+
+    if (!configPath) {
+        return console.red('openkbs.json not found.');
+    }
+
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+    console.log(`Stack: ${config.name || 'unnamed'}`);
+    console.log(`Region: ${config.region || 'us-east-1'}\n`);
+
+    // Get KB token
+    const settings = findSettings();
+    if (!settings?.kbId) {
+        return console.red('No kbId found. Run from a directory with settings.json');
+    }
+
+    const res = await fetchKBJWT(settings.kbId);
+    if (!res?.kbToken) {
+        return console.red(`KB ${settings.kbId} not found`);
+    }
+    const kbToken = res.kbToken;
+
+    // Check functions
+    if (config.functions && config.functions.length > 0) {
+        console.log('Functions:');
+        const listRes = await makePostRequest(KB_API_URL, {
+            token: kbToken,
+            action: 'listElasticFunctions'
+        });
+        const deployed = listRes.functions?.map(f => f.functionName) || [];
+
+        for (const fnName of config.functions) {
+            const name = typeof fnName === 'object' ? fnName.name : fnName;
+            if (deployed.includes(name)) {
+                const fn = listRes.functions.find(f => f.functionName === name);
+                console.green(`  ✓ ${name} (${fn.customUrl || fn.functionUrl})`);
+            } else {
+                console.yellow(`  ○ ${name} (not deployed)`);
+            }
+        }
+        console.log('');
+    }
+
+    // Check elastic services
+    if (config.elastic) {
+        console.log('Elastic Services:');
+
+        if (config.elastic.storage) {
+            const storageRes = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'getElasticStorage'
+            });
+            if (storageRes.enabled) {
+                console.green(`  ✓ Storage (${storageRes.bucket})`);
+            } else {
+                console.yellow('  ○ Storage (not enabled)');
+            }
+        }
+
+        if (config.elastic.postgres) {
+            const pgRes = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'getElasticPostgres'
+            });
+            if (pgRes.enabled) {
+                console.green(`  ✓ Postgres (${pgRes.host})`);
+            } else {
+                console.yellow('  ○ Postgres (not enabled)');
+            }
+        }
+
+        if (config.elastic.pulse) {
+            const pulseRes = await makePostRequest(KB_API_URL, {
+                token: kbToken,
+                action: 'getElasticPulse'
+            });
+            if (pulseRes.enabled) {
+                console.green(`  ✓ Pulse (${pulseRes.endpoint})`);
+            } else {
+                console.yellow('  ○ Pulse (not enabled)');
+            }
+        }
+    }
+
+    // Site info
+    if (config.site) {
+        console.log('');
+        console.log(`Site: https://files.openkbs.com/${settings.kbId}/`);
+    }
+}
+
+/**
+ * Stack command handler
+ */
+async function stackAction(subCommand, args = []) {
+    switch (subCommand) {
+        case 'deploy':
+            return await elasticDeployAction();
+        case 'destroy':
+            return await elasticDestroyAction();
+        case 'status':
+            return await elasticStatusAction();
+        default:
+            console.log('Usage: openkbs stack <command>');
+            console.log('');
+            console.log('Commands:');
+            console.log('  deploy     Deploy all resources from openkbs.json');
+            console.log('  destroy    Delete all resources (DANGEROUS)');
+            console.log('  status     Show status of all resources');
+    }
+}
+
 module.exports = {
     signAction,
     loginAction,
@@ -2156,5 +2471,7 @@ module.exports = {
     siteAction,
     storageAction,
     postgresAction,
-    pulseAction
+    pulseAction,
+    stackAction,
+    elasticDeployAction
 };

package/src/index.js

@@ -18,7 +18,9 @@ const {
     siteAction,
     storageAction,
     postgresAction,
-    pulseAction
+    pulseAction,
+    stackAction,
+    elasticDeployAction
 } = require('./actions');
 
 
@@ -113,16 +115,33 @@ program
     .action(describeAction);
 
 program
-    .command('deploy [moduleName]')
-    .description('Builds and deploys a specified moduleName to "dist" module folder. If moduleName is not provided, deploys all modules.')
-    .action(deployAction)
+    .command('deploy')
+    .description('Deploy from openkbs.json - enables elastic services, deploys functions and site')
+    .action(elasticDeployAction)
     .addHelpText('after', `
 Examples:
   $ openkbs deploy
-  $ openkbs deploy onRequest
-  $ openkbs deploy onResponse
-  $ openkbs deploy onAddMessages
-  $ openkbs deploy contentRender
+
+Reads openkbs.json and deploys:
+  - Elastic services (pulse, postgres, storage)
+  - Functions
+  - Site
+`);
+
+program
+    .command('stack <subcommand>')
+    .description('Manage stack resources (deploy, destroy, status)')
+    .action((subCommand) => stackAction(subCommand))
+    .addHelpText('after', `
+Commands:
+  deploy     Deploy all resources from openkbs.json
+  destroy    Delete all resources (DANGEROUS)
+  status     Show status of all resources
+
+Examples:
+  $ openkbs stack deploy
+  $ openkbs stack status
+  $ openkbs stack destroy
 `);
 
 // program

package/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.61",
-  "releaseDate": "2025-12-30",
-  "releaseNotes": "OpenKBS CLI version 0.0.61"
+  "version": "0.0.64",
+  "releaseDate": "2025-12-31",
+  "releaseNotes": "OpenKBS CLI version 0.0.64"
 }