local-bdk-cli 1.0.7

package/dist/commands/run.js

@@ -0,0 +1,220 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRun = registerRun;
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const localstore_1 = require("../lib/localstore");
+function registerRun(program) {
+    program
+        .command('run [source]')
+        .alias('apps:run')
+        .description('Run the app locally with live reload')
+        .option('--port <number>', 'port to run', '3000')
+        .option('--env <env>', 'environment', 'dev')
+        .option('--open', 'open browser after start', false)
+        .action((sourceArg, opts) => {
+        const sourceDir = path.resolve(process.cwd(), sourceArg || '.');
+        const port = parseInt(opts.port || '3000', 10);
+        const env = opts.env || 'dev';
+        // Check if manifest.json exists
+        const manifestPath = path.join(sourceDir, 'manifest.json');
+        if (!fs.existsSync(manifestPath)) {
+            console.error(`manifest.json not found in ${sourceDir}`);
+            process.exit(1);
+        }
+        // Initialize LocalStore for local database operations
+        const localStore = new localstore_1.LocalStore(path.join(sourceDir, '.bdk/localstore'));
+        // Handler for database operations
+        const handleDBRequest = (operation, key, value) => {
+            try {
+                switch (operation) {
+                    case 'set':
+                        return localStore.store(key, value);
+                    case 'get':
+                        return localStore.fetch(key);
+                    case 'update':
+                        return localStore.update(key, value);
+                    case 'delete':
+                        return localStore.delete(key);
+                    default:
+                        throw new Error(`Unknown database operation: ${operation}`);
+                }
+            }
+            catch (error) {
+                console.error(`[DB] ERROR (${operation} ${key}): ${error.message}`);
+                throw error;
+            }
+        };
+        // Create HTTP server
+        const server = http.createServer((req, res) => {
+            var _a;
+            // Add CORS headers
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            // Handle OPTIONS requests
+            if (req.method === 'OPTIONS') {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
+            // Handle database API requests
+            if (((_a = req.url) === null || _a === void 0 ? void 0 : _a.startsWith('/api/db')) && req.method === 'POST') {
+                let body = '';
+                req.on('data', (chunk) => {
+                    body += chunk.toString();
+                });
+                req.on('error', (error) => {
+                    console.error(`[DB] Request error:`, error);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: 'Request error' }));
+                });
+                req.on('end', () => {
+                    try {
+                        if (!body)
+                            throw new Error('Empty request body');
+                        const payload = JSON.parse(body);
+                        const result = handleDBRequest(payload.operation, payload.key, payload.value);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: true, data: result }));
+                    }
+                    catch (error) {
+                        console.error(`[DB] Error:`, error);
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ success: false, error: error.message }));
+                    }
+                });
+                return;
+            }
+            // Handle static file requests
+            let filePath = req.url || '/';
+            if (filePath === '/') {
+                filePath = '/assets/iframe.html';
+            }
+            // Resolve the file path
+            const fullPath = path.join(sourceDir, filePath);
+            // Security: prevent directory traversal attacks
+            const resolvedPath = path.resolve(fullPath);
+            const basePath = path.resolve(sourceDir);
+            if (!resolvedPath.startsWith(basePath)) {
+                res.writeHead(403, { 'Content-Type': 'text/plain' });
+                res.end('Forbidden');
+                return;
+            }
+            // Try to serve the file
+            fs.readFile(resolvedPath, (err, data) => {
+                if (err) {
+                    // If file not found, try to serve index.html or 404
+                    if (err.code === 'ENOENT') {
+                        res.writeHead(404, { 'Content-Type': 'text/html' });
+                        res.end(`
+                <!DOCTYPE html>
+                <html>
+                <head><title>404 Not Found</title></head>
+                <body>
+                  <h1>404 - File Not Found</h1>
+                  <p>Could not find: ${filePath}</p>
+                  <p><a href="/">Go back</a></p>
+                </body>
+                </html>
+              `);
+                    }
+                    else {
+                        res.writeHead(500, { 'Content-Type': 'text/plain' });
+                        res.end('Internal Server Error');
+                    }
+                    return;
+                }
+                // Determine content type
+                const ext = path.extname(resolvedPath);
+                let contentType = 'application/octet-stream';
+                if (ext === '.html')
+                    contentType = 'text/html; charset=utf-8';
+                else if (ext === '.js')
+                    contentType = 'application/javascript; charset=utf-8';
+                else if (ext === '.json')
+                    contentType = 'application/json; charset=utf-8';
+                else if (ext === '.css')
+                    contentType = 'text/css; charset=utf-8';
+                else if (ext === '.svg')
+                    contentType = 'image/svg+xml';
+                else if (ext === '.png')
+                    contentType = 'image/png';
+                else if (ext === '.jpg' || ext === '.jpeg')
+                    contentType = 'image/jpeg';
+                else if (ext === '.gif')
+                    contentType = 'image/gif';
+                res.writeHead(200, { 'Content-Type': contentType });
+                res.end(data);
+            });
+        });
+        server.listen(port, () => {
+            console.log(`✅ Dev server started on http://localhost:${port} (env=${env})`);
+            console.log(`📁 Serving from: ${sourceDir}`);
+            console.log(`📄 Iframe: http://localhost:${port}/assets/iframe.html`);
+            console.log(`💾 Database: Local storage at ${localStore.getFilePath()}`);
+            console.log(`\nPress Ctrl+C to stop the server\n`);
+            // Open browser if --open flag is set
+            if (opts.open) {
+                const url = `http://localhost:${port}`;
+                try {
+                    const isWindows = process.platform === 'win32';
+                    const command = isWindows
+                        ? `start ${url}`
+                        : process.platform === 'darwin'
+                            ? `open ${url}`
+                            : `xdg-open ${url}`;
+                    (0, child_process_1.execSync)(command, { stdio: 'ignore' });
+                }
+                catch (e) {
+                    // Silently ignore if browser open fails
+                }
+            }
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.error(`❌ Port ${port} is already in use. Try a different port:`);
+                console.error(`   npx bdk apps:run [source] --port 3001`);
+            }
+            else {
+                console.error(`❌ Server error: ${err.message}`);
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/commands/test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTest = registerTest;
+const child_process_1 = require("child_process");
+function registerTest(program) {
+    program
+        .command('test [source]')
+        .alias('apps:test')
+        .description('Run unit and integration tests')
+        .option('--watch', 're-run tests on file changes', false)
+        .option('--coverage', 'generate coverage report', false)
+        .action((sourceArg, opts) => {
+        const path = require('path');
+        const fs = require('fs');
+        const cwd = path.resolve(process.cwd(), sourceArg || '.');
+        // Check if package.json exists and has test script
+        const pkgPath = path.join(cwd, 'package.json');
+        const hasPkg = (() => {
+            try {
+                if (!fs.existsSync(pkgPath)) {
+                    return false;
+                }
+                const p = require(pkgPath);
+                return !!p.scripts && (p.scripts.test || p.scripts['test:watch']);
+            }
+            catch (e) {
+                return false;
+            }
+        })();
+        if (!hasPkg) {
+            console.error('No test script found in package.json. Please add a `test` script.');
+            process.exit(1);
+        }
+        if (opts.watch) {
+            // prefer npm run test -- --watch if available
+            try {
+                console.log('Running tests in watch mode...');
+                const child = (0, child_process_1.spawn)('npm', ['run', 'test', '--', '--watch'], { stdio: 'inherit', cwd: cwd, shell: true });
+                child.on('exit', (code) => process.exit(code || 0));
+            }
+            catch (e) {
+                console.error('Failed to start watch tests:', e);
+                process.exit(2);
+            }
+            return;
+        }
+        try {
+            const args = ['run', 'test'];
+            if (opts.coverage) {
+                // many projects use `npm run test -- --coverage` to enable coverage
+                args.push('--', '--coverage');
+            }
+            console.log('Running tests...');
+            (0, child_process_1.execSync)('npm ' + args.join(' '), { stdio: 'inherit', cwd: cwd });
+        }
+        catch (e) {
+            console.error('Tests failed.');
+            process.exit(e.status || 1);
+        }
+    });
+}

package/dist/commands/validate.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerValidate = registerValidate;
+const path = __importStar(require("path"));
+const package_1 = require("../lib/package");
+const appPath_1 = require("../lib/appPath");
+function registerValidate(program) {
+    program
+        .command('validate [appDirectory]')
+        .alias('apps:validate')
+        .description('Validate app structure and manifest')
+        .action(async (appDirectory = '.') => {
+        try {
+            (0, appPath_1.validateAppPath)(appDirectory);
+            const appPath = path.resolve(appDirectory);
+            await (0, package_1.validatePkg)(appPath);
+            console.log('No validation errors');
+        }
+        catch (err) {
+            console.error(err && err.message ? err.message : err);
+            process.exit(2);
+        }
+    });
+}

package/dist/commands/version.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVersion = registerVersion;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function bumpVersion(v, level) {
+    const parts = v.split('.').map((s) => parseInt(s, 10));
+    while (parts.length < 3)
+        parts.push(0);
+    if (level === 'patch')
+        parts[2] = (parts[2] || 0) + 1;
+    if (level === 'minor') {
+        parts[1] = (parts[1] || 0) + 1;
+        parts[2] = 0;
+    }
+    if (level === 'major') {
+        parts[0] = (parts[0] || 0) + 1;
+        parts[1] = 0;
+        parts[2] = 0;
+    }
+    return parts.join('.');
+}
+function registerVersion(program) {
+    program
+        .command('version [source]')
+        .alias('apps:version')
+        .description('Show or bump app version')
+        .option('--bump <level>', 'patch|minor|major')
+        .option('--set <version>', 'set exact version')
+        .action((sourceArg, opts) => {
+        const manifestPath = path_1.default.resolve(process.cwd(), sourceArg || '.', 'manifest.json');
+        if (!fs_1.default.existsSync(manifestPath)) {
+            console.error('manifest.json not found at', manifestPath);
+            process.exit(1);
+        }
+        const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+        let version = manifest.version || '0.0.0';
+        if (opts.set) {
+            version = opts.set;
+            manifest.version = version;
+            fs_1.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+            console.log(`Set version to ${version}`);
+            process.exit(0);
+        }
+        if (opts.bump) {
+            const level = opts.bump;
+            if (!['patch', 'minor', 'major'].includes(level)) {
+                console.error('Invalid bump level. Use patch, minor or major.');
+                process.exit(2);
+            }
+            version = bumpVersion(version, level);
+            manifest.version = version;
+            fs_1.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+            console.log(`Bumped version to ${version}`);
+            process.exit(0);
+        }
+        console.log(version);
+    });
+}

package/dist/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const create_1 = require("./commands/create");
+const run_1 = require("./commands/run");
+const validate_1 = require("./commands/validate");
+const pack_1 = require("./commands/pack");
+const test_1 = require("./commands/test");
+const version_1 = require("./commands/version");
+const publish_1 = require("./commands/publish");
+const help_1 = require("./commands/help");
+const pkg = require('../package.json');
+const program = new commander_1.Command();
+program.name('bdk').version(pkg.version).description('BoldDesk Developer Kit CLI');
+(0, create_1.registerCreate)(program);
+(0, run_1.registerRun)(program);
+(0, validate_1.registerValidate)(program);
+(0, pack_1.registerPack)(program);
+(0, test_1.registerTest)(program);
+(0, version_1.registerVersion)(program);
+(0, publish_1.registerPublish)(program);
+(0, help_1.registerHelp)(program);
+program.parse(process.argv);

package/dist/lib/appPath.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAppPath = validateAppPath;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function validateAppPath(appPath) {
+    const resolved = path_1.default.resolve(appPath);
+    if (!fs_1.default.existsSync(resolved))
+        throw new Error(`App path does not exist: ${resolved}`);
+    const manifest = path_1.default.join(resolved, 'manifest.json');
+    if (!fs_1.default.existsSync(manifest))
+        throw new Error(`manifest.json not found in ${resolved}`);
+    return true;
+}

package/dist/lib/localstore.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * BoldDesk LocalStore - Persistent local data storage during development
+ *
+ * Similar to Freshdesk FDK's DataStore (lib/utils/data.js)
+ * Stores key-value data in .bolddesk/localstore JSON file
+ *
+ * Key Format: '1234' or '1234:{jiraId:9878}' (first part is the key)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * LocalStore class for managing persistent local storage
+ * Mirrors Freshdesk's DataStore functionality
+ */
+class LocalStore {
+    constructor(filePath = '.bdk/localstore') {
+        this.data = {};
+        this.filePath = filePath;
+        this.ensureStore();
+    }
+    /**
+     * Ensure localstore folder and file exist
+     * Creates .bolddesk folder if needed
+     * Creates empty JSON file if needed
+     */
+    ensureStore() {
+        const folder = path.dirname(this.filePath);
+        if (!fs.existsSync(folder)) {
+            fs.mkdirSync(folder, { recursive: true });
+        }
+        if (!fs.existsSync(this.filePath)) {
+            fs.writeFileSync(this.filePath, JSON.stringify({}));
+        }
+    }
+    /**
+     * Validate key format and constraints
+     * - Max 60 characters
+     * - Cannot be empty
+     * - Alphanumeric, dash, underscore, colon allowed
+     */
+    validateKey(key) {
+        if (!key || typeof key !== 'string') {
+            throw new Error('The key cannot be blank');
+        }
+    }
+    /**
+     * Read localstore file from disk
+     * Returns parsed JSON object
+     * Returns empty object on error
+     */
+    readLocalStore() {
+        try {
+            if (!fs.existsSync(this.filePath)) {
+                return {};
+            }
+            const content = fs.readFileSync(this.filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (e) {
+            console.error(`[LocalStore] Error reading file: ${e.message}`);
+            return {};
+        }
+    }
+    /**
+     * Write localstore file to disk
+     * Pretty-prints JSON for human readability
+     */
+    writeLocalStore(data) {
+        try {
+            fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            console.error(`[LocalStore] Error writing file: ${e.message}`);
+            throw e;
+        }
+    }
+    /**
+     * Store operation - SET key/value
+     * Stores data as-is without modification
+     *
+     * @param key Storage key (e.g., 'ticket-001')
+     * @param data Value to store (JSON object)
+     * @returns { Created: true }
+     */
+    store(key, data) {
+        this.validateKey(key);
+        const localStoreData = this.readLocalStore();
+        localStoreData[key] = data;
+        this.writeLocalStore(localStoreData);
+        return { Created: true };
+    }
+    /**
+     * Fetch operation - GET key/value
+     * Retrieves stored data for a key
+     *
+     * @param key Storage key to retrieve
+     * @returns Stored data or undefined if not found
+     */
+    fetch(key) {
+        const localStoreData = this.readLocalStore();
+        return localStoreData[key];
+    }
+    /**
+     * Update operation - PATCH key with new values
+     * Merges attributes with existing data
+     *
+     * @param key Storage key to update
+     * @param attributes Object with fields to merge
+     * @returns { Updated: true }
+     */
+    update(key, attributes) {
+        this.validateKey(key);
+        const localStoreData = this.readLocalStore();
+        const existingRecord = localStoreData[key];
+        if (!existingRecord) {
+            throw new Error(`Record not found for key: ${key}`);
+        }
+        localStoreData[key] = { ...existingRecord, ...attributes };
+        this.writeLocalStore(localStoreData);
+        return { Updated: true };
+    }
+    /**
+     * Delete operation - DELETE key
+     * Similar to Freshdesk DataStore.delete()
+     *
+     * @param key Storage key to delete
+     * @returns { Deleted: true }
+     */
+    delete(key) {
+        const localStoreData = this.readLocalStore();
+        delete localStoreData[key];
+        this.writeLocalStore(localStoreData);
+        return { Deleted: true };
+    }
+    /**
+     * Get the file path to localstore
+     */
+    getFilePath() {
+        return this.filePath;
+    }
+    /**
+     * Get all stored data (for debugging)
+     */
+    getAll() {
+        return this.readLocalStore();
+    }
+    /**
+     * Clear all data from localstore
+     */
+    clear() {
+        this.writeLocalStore({});
+    }
+}
+exports.LocalStore = LocalStore;