test-bdk-cli 1.0.2 → 1.0.4

package/dist/commands/create.js

@@ -0,0 +1,314 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCreate = registerCreate;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// inquirer is ESM-only; import dynamically at runtime to avoid require() errors
+const child_process_1 = require("child_process");
+const package_1 = require("../lib/package");
+const createApp_1 = require("../utils/createApp");
+const uploadApp_1 = require("../utils/uploadApp");
+const appConfig_1 = require("../utils/appConfig");
+const getAppSettings_1 = require("../utils/getAppSettings");
+function registerCreate(program) {
+    program
+        .command('apps:create [appDirectories...]')
+        .description('Scaffold one or more new app projects (usage: apps:create ./appName)')
+        .option('--template <template>', 'template name', 'default')
+        .option('--path <dir>', 'base path for created directories', '.')
+        .option('--force', 'overwrite if exists', false)
+        .option('--git', 'initialize a git repository', false)
+        .option('--npm', 'run npm init -y in the new project', false)
+        .option('--deploy', 'upload and deploy the app to BoldDesk', false)
+        .option('--api-url <url>', 'BoldDesk API base URL (env BOLD_API_URL)')
+        .option('--token <token>', 'BoldDesk API token (env BOLD_API_TOKEN)')
+        .action(async (...args) => {
+        // normalize action arguments: support both (appDirectories..., opts) and (opts) shapes
+        let opts = {};
+        let appDirectories = ['.'];
+        if (args.length === 0) {
+            opts = {};
+            appDirectories = ['.'];
+        }
+        else {
+            // pick the last plain object (non-array) as options if present
+            for (let i = args.length - 1; i >= 0; i--) {
+                const a = args[i];
+                if (typeof a === 'object' && !Array.isArray(a)) {
+                    opts = a;
+                    break;
+                }
+            }
+            // collect directory arguments: strings or arrays of strings
+            const collected = [];
+            for (const a of args) {
+                if (typeof a === 'string')
+                    collected.push(a);
+                else if (Array.isArray(a)) {
+                    for (const s of a)
+                        if (typeof s === 'string')
+                            collected.push(s);
+                }
+            }
+            appDirectories = collected.length ? collected : ['.'];
+        }
+        const template = opts.template || 'default';
+        const basePath = path_1.default.resolve(opts.path || '.');
+        // flatten nested array if commander wrapped variadic into single array
+        if (Array.isArray(appDirectories) && appDirectories.length === 1 && Array.isArray(appDirectories[0])) {
+            appDirectories = appDirectories[0];
+        }
+        const templatesDir = path_1.default.resolve(__dirname, '../../templates', template);
+        if (!fs_1.default.existsSync(templatesDir)) {
+            console.error(`Template not found: ${templatesDir}`);
+            process.exit(2);
+        }
+        for (const appDir of appDirectories) {
+            const targetDir = path_1.default.resolve(basePath, appDir);
+            const appName = path_1.default.basename(targetDir);
+            if (fs_1.default.existsSync(targetDir) && !opts.force) {
+                const dynamicImport = new Function('s', 'return import(s)');
+                const _inquirer = (await dynamicImport('inquirer')).default || (await dynamicImport('inquirer'));
+                const { overwrite } = await _inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'overwrite',
+                        message: `Target directory ${targetDir} exists. Overwrite?`,
+                        default: false
+                    }
+                ]);
+                if (!overwrite) {
+                    console.error('Aborted by user.');
+                    continue;
+                }
+            }
+            fs_1.default.mkdirSync(targetDir, { recursive: true });
+            // Copy template directory. Use built-in cp if available, otherwise fallback to recursive copy.
+            if (fs_1.default.promises.cp) {
+                await fs_1.default.promises.cp(templatesDir, targetDir, { recursive: true });
+            }
+            else {
+                // recursive copy fallback
+                async function copyRecursive(src, dest) {
+                    const entries = await fs_1.default.promises.readdir(src, { withFileTypes: true });
+                    await fs_1.default.promises.mkdir(dest, { recursive: true });
+                    for (const entry of entries) {
+                        const srcPath = path_1.default.join(src, entry.name);
+                        const destPath = path_1.default.join(dest, entry.name);
+                        if (entry.isDirectory()) {
+                            await copyRecursive(srcPath, destPath);
+                        }
+                        else if (entry.isSymbolicLink()) {
+                            try {
+                                const link = await fs_1.default.promises.readlink(srcPath);
+                                await fs_1.default.promises.symlink(link, destPath);
+                            }
+                            catch (e) {
+                                // fallback to copyFile if symlink fails
+                                await fs_1.default.promises.copyFile(srcPath, destPath);
+                            }
+                        }
+                        else {
+                            await fs_1.default.promises.copyFile(srcPath, destPath);
+                        }
+                    }
+                }
+                await copyRecursive(templatesDir, targetDir);
+            }
+            // Ensure template contains basic assets and translations. If the template
+            // did not include them, create defaults (iframe, logos, translations).
+            try {
+                const assetsDir = path_1.default.join(targetDir, 'assets');
+                if (!fs_1.default.existsSync(assetsDir))
+                    fs_1.default.mkdirSync(assetsDir, { recursive: true });
+                const iframePath = path_1.default.join(assetsDir, 'iframe.html');
+                if (!fs_1.default.existsSync(iframePath)) {
+                    fs_1.default.writeFileSync(iframePath, `<!doctype html>\n<html lang="en">\n  <head>\n    <meta charset="utf-8" />\n    <meta name="viewport" content="width=device-width,initial-scale=1" />\n    <title>Sample Iframe</title>\n    <style>body{font-family:Arial,Helvetica,sans-serif;padding:20px}</style>\n  </head>\n  <body>\n    <h1>Hello from the app iframe</h1>\n    <p>This is a simple placeholder iframe page generated by the CLI.</p>\n  </body>\n</html>\n`, 'utf8');
+                }
+                const logoPath = path_1.default.join(assetsDir, 'logo.svg');
+                if (!fs_1.default.existsSync(logoPath)) {
+                    fs_1.default.writeFileSync(logoPath, `<svg xmlns="http://www.w3.org/2000/svg" width="240" height="240" viewBox="0 0 240 240">\n  <rect width="240" height="240" rx="24" fill="#0b6c6c" />\n  <g fill="#fff" transform="translate(40,40)">\n    <rect x="0" y="0" width="160" height="160" rx="12" />\n  </g>\n</svg>\n`, 'utf8');
+                }
+                const logoSmall = path_1.default.join(assetsDir, 'logo-small.svg');
+                if (!fs_1.default.existsSync(logoSmall)) {
+                    fs_1.default.writeFileSync(logoSmall, `<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">\n  <rect width="64" height="64" rx="8" fill="#0b6c6c" />\n  <rect x="12" y="12" width="40" height="40" rx="6" fill="#fff" />\n</svg>\n`, 'utf8');
+                }
+                const translationsDir = path_1.default.join(targetDir, 'translations');
+                if (!fs_1.default.existsSync(translationsDir))
+                    fs_1.default.mkdirSync(translationsDir, { recursive: true });
+                const enPath = path_1.default.join(translationsDir, 'en.json');
+                if (!fs_1.default.existsSync(enPath)) {
+                    fs_1.default.writeFileSync(enPath, JSON.stringify({
+                        app: {
+                            name: 'Sample BoldDesk App',
+                            short_description: 'A short description of your BoldDesk app.',
+                            long_description: 'A longer description of your BoldDesk app and its features. Replace this text with real product details.',
+                            installation_instructions: 'Follow the installation steps in the BoldDesk admin to install this app.'
+                        }
+                    }, null, 2), 'utf8');
+                }
+            }
+            catch (e) {
+                // ignore any template-creation errors
+            }
+            const manifestPath = path_1.default.resolve(targetDir, 'manifest.json');
+            // If template didn't include a manifest, create a sensible default so
+            // the CLI can prompt and the app can be packaged.
+            if (!fs_1.default.existsSync(manifestPath)) {
+                const defaultManifest = {
+                    name: appName,
+                    developer: {
+                        name: '',
+                        contactEmail: '',
+                        supportEmail: '',
+                        privacyUrl: '',
+                        websiteUrl: '',
+                        termsOfUseUrl: ''
+                    },
+                    widgets: [
+                        {
+                            url: 'assets/iframe.html',
+                            name: 'Sample Widget',
+                            location: 'desk.ticket.view.rightpanel'
+                        }
+                    ],
+                    defaultLocale: 'en',
+                    domainWhitelist: [],
+                    private: true,
+                    product: 'BoldDesk',
+                    version: '1.0.0',
+                    frameworkVersion: '2.0',
+                    description: ''
+                };
+                try {
+                    fs_1.default.writeFileSync(manifestPath, JSON.stringify(defaultManifest, null, 2), 'utf8');
+                }
+                catch (e) {
+                    // ignore write errors
+                }
+            }
+            if (fs_1.default.existsSync(manifestPath)) {
+                const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+                const dev = (manifest.developer && typeof manifest.developer === 'object') ? manifest.developer : {};
+                const dynamicImport = new Function('s', 'return import(s)');
+                const _inquirer = (await dynamicImport('inquirer')).default || (await dynamicImport('inquirer'));
+                // Placeholder sentinel values from the template — treat them as empty
+                const templatePlaceholders = new Set([
+                    'Your Name', 'you@example.com', 'https://example.com/privacy',
+                    'https://example.com', 'https://example.com/terms',
+                    'sample-app', 'A sample BoldDesk app scaffolded by the bdk CLI'
+                ]);
+                const clean = (v) => (v && typeof v === 'string' && !templatePlaceholders.has(v.trim())) ? v : '';
+                const answers = await _inquirer.prompt([
+                    { name: 'name', message: 'App name', default: clean(manifest.name) || appName },
+                    { name: 'version', message: 'Version', default: manifest.version || '1.0.0' },
+                    { name: 'description', message: 'Description', default: clean(manifest.description) },
+                    // developer fields — always default to '' so pressing Enter stores empty string
+                    { name: 'devName', message: 'Developer name', default: clean(dev.name) },
+                    { name: 'devContactEmail', message: 'Developer contact email', default: clean(dev.contactEmail) },
+                    { name: 'devSupportEmail', message: 'Developer support email', default: clean(dev.supportEmail) },
+                    { name: 'devPrivacyUrl', message: 'Developer privacy URL', default: clean(dev.privacyUrl) },
+                    { name: 'devWebsiteUrl', message: 'Developer website URL', default: clean(dev.websiteUrl) },
+                    { name: 'devTermsUrl', message: 'Developer terms of use URL', default: clean(dev.termsOfUseUrl) }
+                ]);
+                const newManifest = {
+                    ...manifest,
+                    name: answers.name,
+                    version: answers.version,
+                    description: answers.description,
+                    developer: {
+                        name: answers.devName,
+                        contactEmail: answers.devContactEmail,
+                        supportEmail: answers.devSupportEmail,
+                        privacyUrl: answers.devPrivacyUrl,
+                        websiteUrl: answers.devWebsiteUrl,
+                        termsOfUseUrl: answers.devTermsUrl
+                    }
+                };
+                // Remove legacy 'author' field if present
+                delete newManifest.author;
+                fs_1.default.writeFileSync(manifestPath, JSON.stringify(newManifest, null, 2), 'utf8');
+                console.log('Updated manifest.json with provided values.');
+            }
+            if (opts.npm) {
+                try {
+                    console.log('Running `npm init -y`...');
+                    (0, child_process_1.execSync)('npm init -y', { cwd: targetDir, stdio: 'inherit' });
+                }
+                catch (e) {
+                    console.warn('npm init failed:', e.message);
+                }
+            }
+            if (opts.git) {
+                try {
+                    console.log('Initializing git repository...');
+                    (0, child_process_1.execSync)('git init', { cwd: targetDir, stdio: 'inherit' });
+                    (0, child_process_1.execSync)('git add .', { cwd: targetDir, stdio: 'inherit' });
+                    (0, child_process_1.execSync)('git commit -m "chore: scaffold initial project"', { cwd: targetDir, stdio: 'ignore' });
+                }
+                catch (e) {
+                    console.warn('git init/commit failed (git may not be installed or user identity not set).');
+                }
+            }
+            console.log(`Created ${appName} at ${targetDir} from template ${template}`);
+            // If deploy flag is set, package and upload to BoldDesk
+            if (opts.deploy) {
+                const API_URL = opts.apiUrl || process.env.BOLD_API_URL;
+                const API_TOKEN = opts.token || process.env.BOLD_API_TOKEN;
+                if (!API_URL || !API_TOKEN) {
+                    console.error('Missing BoldDesk API configuration. Set --api-url and --token or BOLD_API_URL and BOLD_API_TOKEN environment variables.');
+                    process.exit(4);
+                }
+                try {
+                    console.log('Creating app package...');
+                    const pkgPath = await (0, package_1.createAppPkg)(targetDir, appName);
+                    console.log('Uploading package to BoldDesk...');
+                    const uploadRes = await (0, createApp_1.uploadAppPkg)(API_URL, API_TOKEN, pkgPath);
+                    if (!uploadRes || !uploadRes.upload_id) {
+                        console.error('Upload failed: no upload_id returned');
+                        process.exit(5);
+                    }
+                    console.log('Deploying uploaded package...');
+                    const deployRes = await (0, createApp_1.deployApp)(API_URL, API_TOKEN, uploadRes.upload_id, appName);
+                    if (!deployRes || !deployRes.job_id) {
+                        console.error('Deploy failed: no job_id returned');
+                        process.exit(6);
+                    }
+                    console.log('Polling job status...');
+                    const jobResult = await (0, uploadApp_1.getUploadJobStatus)(API_URL, API_TOKEN, deployRes.job_id);
+                    if (!jobResult || !jobResult.app_id) {
+                        console.error('Job did not produce an app_id');
+                        process.exit(7);
+                    }
+                    console.log(`Deployed successfully with app_id: ${jobResult.app_id}`);
+                    // Optionally create product installations if manifest specifies locations
+                    const manifestPath2 = path_1.default.resolve(targetDir, 'manifest.json');
+                    if (fs_1.default.existsSync(manifestPath2)) {
+                        const manifest2 = JSON.parse(fs_1.default.readFileSync(manifestPath2, 'utf8'));
+                        const allConfigs = (0, appConfig_1.getAllConfigs)(targetDir);
+                        const configParams = (allConfigs === null || allConfigs === void 0 ? void 0 : allConfigs.parameters) || {};
+                        const settings = manifest2.parameters ? await (0, getAppSettings_1.getAppSettings)(manifest2, configParams) : {};
+                        if (!manifest2.requirementsOnly && manifest2.location) {
+                            for (const product of Object.keys(manifest2.location)) {
+                                const installed = await (0, createApp_1.createProductInstallation)(API_URL, API_TOKEN, settings, manifest2, jobResult.app_id, product);
+                                if (!installed) {
+                                    console.error(`Failed to create installation for product ${product}`);
+                                }
+                                else {
+                                    console.log(`Installed on product ${product}`);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    console.error('Deploy flow failed:', e && e.message ? e.message : e);
+                    process.exit(8);
+                }
+            }
+        }
+    });
+}

package/dist/commands/help.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHelp = registerHelp;
+const COMMANDS = [
+    {
+        command: 'apps:create',
+        alias: 'apps:create [appDirectories...]',
+        description: 'Scaffold one or more new app projects from a template.',
+        usage: 'bdk apps:create ./my-app [--template default] [--git] [--npm] [--deploy]',
+    },
+    {
+        command: 'apps:run',
+        alias: 'apps:run [source]',
+        description: 'Start a local dev server with live file serving for the app.',
+        usage: 'bdk apps:run [source] [--port 3000] [--env dev] [--open]',
+    },
+    {
+        command: 'apps:validate',
+        alias: 'apps:validate [appDirectory]',
+        description: 'Validate the app structure and manifest.json against the schema.',
+        usage: 'bdk apps:validate [appDirectory]',
+    },
+    {
+        command: 'apps:pack',
+        alias: 'apps:pack [source]',
+        description: 'Package the app into a zip/tar archive ready for publishing.',
+        usage: 'bdk apps:pack [source] [--output ./dist] [--format zip|tar]',
+    },
+    {
+        command: 'apps:test',
+        alias: 'apps:test [source]',
+        description: 'Run the app\'s unit and integration tests via npm test.',
+        usage: 'bdk apps:test [source] [--watch] [--coverage]',
+    },
+    {
+        command: 'apps:version',
+        alias: 'apps:version [source]',
+        description: 'Show or bump the app version in manifest.json.',
+        usage: 'bdk apps:version [source] [--bump patch|minor|major] [--set <version>]',
+    },
+    {
+        command: 'apps:help',
+        alias: 'apps:help [command]',
+        description: 'Show the list of available commands with descriptions and usage.',
+        usage: 'bdk apps:help [command]',
+    },
+];
+function registerHelp(program) {
+    program
+        .command('help [commandName]')
+        .alias('apps:help')
+        .description('Show available commands and their descriptions')
+        .action((commandName) => {
+        if (commandName) {
+            // Show detailed info for a specific command
+            const found = COMMANDS.find((c) => c.command.toLowerCase() === commandName.toLowerCase() ||
+                c.command.toLowerCase() === `apps:${commandName.toLowerCase()}`);
+            if (!found) {
+                console.error(`\n  Unknown command: "${commandName}"`);
+                console.error(`  Run "bdk apps:help" to see all available commands.\n`);
+                process.exit(1);
+                return;
+            }
+            console.log('');
+            console.log(`  Command  : ${found.command}`);
+            console.log(`  Synopsis : ${found.alias}`);
+            console.log(`  Info     : ${found.description}`);
+            console.log(`  Usage    : ${found.usage}`);
+            console.log('');
+        }
+        else {
+            // Show summary of all commands
+            console.log('');
+            console.log('  BoldDesk Developer Kit (bdk) — Available Commands');
+            console.log('  ' + '─'.repeat(55));
+            const maxCmd = Math.max(...COMMANDS.map((c) => c.command.length));
+            for (const cmd of COMMANDS) {
+                const padding = ' '.repeat(maxCmd - cmd.command.length + 2);
+                console.log(`  ${cmd.command}${padding}${cmd.description}`);
+            }
+        }
+    });
+}

package/dist/commands/pack.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPack = registerPack;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const archiver_1 = __importDefault(require("archiver"));
+const ajv_1 = __importDefault(require("ajv"));
+const child_process_1 = require("child_process");
+function registerPack(program) {
+    program
+        .command('pack [source]')
+        .alias('apps:pack')
+        .description('Package the app for publishing')
+        .option('--output <path>', 'output directory or filename', './dist')
+        .option('--format <fmt>', 'archive format (zip|tar)', 'zip')
+        .option('--no-validate', 'skip manifest validation')
+        .option('--source <dir>', 'source directory to package', '.')
+        .action(async (sourceArg, opts) => {
+        const sourceDir = path_1.default.resolve(process.cwd(), sourceArg || opts.source || '.');
+        const manifestPath = path_1.default.resolve(sourceDir, 'manifest.json');
+        if (!fs_1.default.existsSync(manifestPath)) {
+            console.error('manifest.json not found in source directory:', sourceDir);
+            process.exit(1);
+        }
+        if (opts.validate !== false) {
+            const schemaPath = path_1.default.resolve(__dirname, '../../schemas/manifest.schema.json');
+            if (fs_1.default.existsSync(schemaPath)) {
+                const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+                const schema = JSON.parse(fs_1.default.readFileSync(schemaPath, 'utf8'));
+                const ajv = new ajv_1.default({ allowUnionTypes: true, allErrors: true });
+                const validate = ajv.compile(schema);
+                const valid = validate(manifest);
+                if (!valid) {
+                    const errs = (validate.errors || []).map((e) => `${(e === null || e === void 0 ? void 0 : e.instancePath) || '/'}: ${e === null || e === void 0 ? void 0 : e.message}`).join('\n');
+                    console.error(`Manifest validation failed for ${manifestPath}:\n${errs}`);
+                    console.error(`Suggestions: ensure 'version' is a valid semver (e.g. 0.1.0), or run 'bdk apps:version <source> --set 0.1.0'. To skip validation: use '--no-validate'.`);
+                    process.exit(2);
+                }
+            }
+            else {
+                console.warn('Schema not found; skipping schema validation.');
+            }
+        }
+        const pkgPath = path_1.default.resolve(sourceDir, 'package.json');
+        if (fs_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+                if (pkg.scripts && pkg.scripts.build) {
+                    try {
+                        console.log('Running build script (npm run build)...');
+                        (0, child_process_1.execSync)('npm run build', { cwd: sourceDir, stdio: 'inherit' });
+                    }
+                    catch (e) {
+                        console.warn('Build failed or returned non-zero exit code; continuing to pack.');
+                    }
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+        const name = manifest.name || path_1.default.basename(sourceDir);
+        const version = manifest.version || '0.0.0';
+        const fmt = (opts.format || 'zip').toLowerCase();
+        const outTarget = opts.output || './dist';
+        // Resolve output path relative to source directory, not current working directory
+        let outputPath = path_1.default.resolve(sourceDir, outTarget);
+        try {
+            const stat = fs_1.default.existsSync(outputPath) && fs_1.default.statSync(outputPath);
+            if (!stat || stat.isDirectory()) {
+                fs_1.default.mkdirSync(outputPath, { recursive: true });
+                const filename = `${name}-${version}.${fmt === 'zip' ? 'zip' : 'tar'}`;
+                outputPath = path_1.default.join(outputPath, filename);
+            }
+        }
+        catch (e) {
+            fs_1.default.mkdirSync(path_1.default.dirname(outputPath), { recursive: true });
+        }
+        const output = fs_1.default.createWriteStream(outputPath);
+        const archive = (0, archiver_1.default)(fmt === 'zip' ? 'zip' : 'tar', fmt === 'zip' ? {} : { gzip: true });
+        output.on('close', () => {
+            console.log(`Created archive: ${outputPath} (${archive.pointer()} bytes)`);
+        });
+        archive.on('warning', (err) => {
+            if (err.code === 'ENOENT')
+                console.warn(err.message);
+            else
+                throw err;
+        });
+        archive.on('error', (err) => {
+            throw err;
+        });
+        archive.pipe(output);
+        const preferDirs = ['dist', 'build', 'public'];
+        let addedAny = false;
+        for (const d of preferDirs) {
+            const p = path_1.default.join(sourceDir, d);
+            if (fs_1.default.existsSync(p) && fs_1.default.statSync(p).isDirectory()) {
+                archive.directory(p, d);
+                addedAny = true;
+            }
+        }
+        if (!addedAny) {
+            archive.glob('**/*', {
+                cwd: sourceDir,
+                ignore: ['node_modules/**', '**/node_modules/**']
+            });
+        }
+        archive.file(manifestPath, { name: 'manifest.json' });
+        await archive.finalize();
+    });
+}

package/dist/commands/publish.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPublish = registerPublish;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+function registerPublish(program) {
+    program
+        .command('publish [source]')
+        .alias('apps:publish')
+        .description('Publish app archive to BoldDesk marketplace')
+        .option('--file <path>', 'package file to upload (zip or tar)')
+        .option('--token <token>', 'API token for BoldDesk')
+        .option('--url <url>', 'publish endpoint URL', 'https://api.bolddesk.com/apps/upload')
+        .option('--dry-run', 'do not actually upload, show what would be sent', false)
+        .option('--private', 'mark uploaded app as private', false)
+        .option('--source <dir>', 'source directory to pack before publishing', '.')
+        .action(async (_sourceArg, _opts) => {
+        // Command is currently disabled — exit silently without any output
+        return;
+        /* ── disabled block ─────────────────────────────────────────────── */
+        // eslint-disable-next-line no-unreachable
+        try {
+            let filePath = _opts.file;
+            const sourceDir = path_1.default.resolve(process.cwd(), _sourceArg || _opts.source || '.');
+            if (!filePath) {
+                console.log('No package file given — running `bdk pack` to create archive...');
+                try {
+                    const cliEntry = path_1.default.resolve(__dirname, '../index.js');
+                    const sourceArg_str = _sourceArg ? `"${_sourceArg}"` : '.';
+                    (0, child_process_1.execSync)(`node "${cliEntry}" pack ${sourceArg_str} --output ./dist --format zip`, { cwd: process.cwd(), stdio: 'inherit' });
+                }
+                catch (e) {
+                    console.error('Automatic pack failed; please run `bdk pack` manually or provide --file');
+                    process.exit(1);
+                }
+                const manifestPath = path_1.default.join(sourceDir, 'manifest.json');
+                if (!fs_1.default.existsSync(manifestPath)) {
+                    console.error('manifest.json missing; cannot determine archive filename.');
+                    process.exit(1);
+                }
+                const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+                const name = manifest.name || path_1.default.basename(sourceDir);
+                const version = manifest.version || '0.0.0';
+                const candidate = path_1.default.resolve(sourceDir, 'dist', `${name}-${version}.zip`);
+                if (!fs_1.default.existsSync(candidate)) {
+                    console.error('Expected archive not found:', candidate);
+                    process.exit(1);
+                }
+                filePath = candidate;
+            }
+            filePath = path_1.default.resolve(process.cwd(), filePath);
+            if (!fs_1.default.existsSync(filePath)) {
+                console.error('Package file not found:', filePath);
+                process.exit(1);
+            }
+            if (_opts.dryRun) {
+                console.log('Dry-run: would upload', filePath, 'to', _opts.url);
+                process.exit(0);
+            }
+            const token = _opts.token || process.env.BOLD_API_TOKEN || process.env.BDK_TOKEN;
+            if (!token) {
+                console.error('No API token provided. Use --token or set BOLD_API_TOKEN/BDK_TOKEN env var.');
+                process.exit(1);
+            }
+            const FormData = require('form-data');
+            const fetch = require('node-fetch');
+            const form = new FormData();
+            form.append('file', fs_1.default.createReadStream(filePath));
+            form.append('private', _opts.private ? 'true' : 'false');
+            console.log(`Uploading ${path_1.default.basename(filePath)} to ${_opts.url} ...`);
+            const res = await fetch(_opts.url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    ...form.getHeaders()
+                },
+                body: form
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                console.error('Upload failed:', res.status, res.statusText, text);
+                process.exit(2);
+            }
+            const json = await res.json();
+            console.log('Publish succeeded:', JSON.stringify(json, null, 2));
+        }
+        catch (err) {
+            console.error('Publish failed:', err && err.message ? err.message : err);
+            process.exit(3);
+        }
+        /* ── end disabled block ─────────────────────────────────────────── */
+    });
+}

package/dist/commands/run.js

@@ -0,0 +1,155 @@
+"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");
+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);
+        }
+        // Create a simple HTTP server
+        const server = http.createServer((req, res) => {
+            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(`\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/package.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppPkg = createAppPkg;
+exports.validatePkg = validatePkg;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const archiver_1 = __importDefault(require("archiver"));
+async function createAppPkg(targetDir, appName) {
+    const outName = `${appName.replace(/[^a-z0-9-_]/gi, '-')}-${Date.now()}.zip`;
+    const outPath = path_1.default.join(os_1.default.tmpdir(), outName);
+    return new Promise((resolve, reject) => {
+        const output = fs_1.default.createWriteStream(outPath);
+        const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+        output.on('close', () => resolve(outPath));
+        output.on('error', (err) => reject(err));
+        archive.on('error', (err) => reject(err));
+        archive.pipe(output);
+        archive.directory(targetDir, false);
+        archive.finalize();
+    });
+}
+async function validatePkg(appPath) {
+    const manifestPath = path_1.default.join(appPath, 'manifest.json');
+    if (!fs_1.default.existsSync(manifestPath))
+        throw new Error(`manifest.json not found in ${appPath}`);
+    const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+    const errors = [];
+    const isEmpty = (v) => v === undefined ||
+        v === null ||
+        (typeof v === 'string' && v.trim() === '') ||
+        (Array.isArray(v) && v.length === 0) ||
+        (typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0);
+    // ── Top-level required fields ──
+    if (isEmpty(manifest.name)) {
+        errors.push("Missing required field in manifest: 'name'.");
+    }
+    if (isEmpty(manifest.version)) {
+        errors.push("Missing required field in manifest: 'version'.");
+    }
+    else if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(manifest.version)) {
+        errors.push(`Invalid 'version' format: "${manifest.version}". Expected semver (e.g., 1.0.0).`);
+    }
+    if (isEmpty(manifest.frameworkVersion)) {
+        errors.push("Framework version (frameworkVersion) is missing.");
+    }
+    if (isEmpty(manifest.defaultLocale)) {
+        errors.push("Missing required field in manifest: 'defaultLocale'.");
+    }
+    // ── Rule: 'author' field is not allowed (replaced by 'developer') ──
+    if ('author' in manifest) {
+        errors.push("The 'author' field is not allowed. Use the 'developer' block instead.");
+    }
+    // ── Rule: 'location' top-level is no longer valid (location belongs inside each widget) ──
+    if ('location' in manifest && !Array.isArray(manifest.location)) {
+        errors.push("Top-level 'location' field is not allowed. Define 'location' inside each widget under 'widgets'.");
+    }
+    // ── Rule: developer block validation (only 'name' is required) ──
+    if (isEmpty(manifest.developer) || typeof manifest.developer !== 'object') {
+        errors.push("The 'developer' block is missing. Please provide developer information.");
+    }
+    else {
+        if (isEmpty(manifest.developer.name)) {
+            errors.push("Developer validation failed: 'developer.name' is required.");
+        }
+    }
+    // ── Rule: widgets array & widget.location ──
+    if (!('widgets' in manifest)) {
+        errors.push("Missing required field in manifest: 'widgets'.");
+    }
+    else if (!Array.isArray(manifest.widgets) || manifest.widgets.length === 0) {
+        errors.push("'widgets' must be a non-empty array.");
+    }
+    else {
+        manifest.widgets.forEach((widget, index) => {
+            const label = widget && widget.name ? widget.name : `index ${index}`;
+            if (isEmpty(widget === null || widget === void 0 ? void 0 : widget.location)) {
+                errors.push(`Widget "${label}": location value is missing.`);
+            }
+            if (isEmpty(widget === null || widget === void 0 ? void 0 : widget.url)) {
+                errors.push(`Widget "${label}": url value is missing.`);
+            }
+            if (isEmpty(widget === null || widget === void 0 ? void 0 : widget.name)) {
+                errors.push(`Widget at index ${index}: name value is missing.`);
+            }
+        });
+    }
+    // ── Rule: OAuth validations ──
+    // If 'oauth' property is NOT present in manifest → skip entirely
+    // If 'oauth' property IS present (even with empty values) → all fields are required
+    if ('oauth' in manifest) {
+        const oauth = manifest.oauth;
+        if (!oauth || typeof oauth !== 'object') {
+            errors.push("'oauth' must be a valid object.");
+        }
+        else {
+            const oauthFieldMap = {
+                clientId: 'oauth.clientId',
+                redirectUri: 'oauth.redirectUri',
+                authorizeUri: 'oauth.authorizeUri',
+                clientSecret: 'oauth.clientSecret',
+                accessTokenUri: 'oauth.accessTokenUri',
+            };
+            for (const [field, label] of Object.entries(oauthFieldMap)) {
+                if (isEmpty(oauth[field])) {
+                    errors.push(`Missing required field: '${label}'.`);
+                }
+            }
+        }
+    }
+    // ── Rule: settings.fields OAuth type check ──
+    // Only enforce when oauth block has actual values AND settings.fields is non-empty
+    if ('settings' in manifest) {
+        const settings = manifest.settings;
+        if (!settings || typeof settings !== 'object') {
+            errors.push("'settings' must be a valid object.");
+        }
+        else if (Array.isArray(settings.fields) && settings.fields.length > 0) {
+            // Each field object must have 'key' and 'type'
+            settings.fields.forEach((field, index) => {
+                const fieldLabel = field && field.key ? `"${field.key}"` : `index ${index}`;
+                if (isEmpty(field === null || field === void 0 ? void 0 : field.key)) {
+                    errors.push(`settings.fields[${index}]: 'key' is required for each field object.`);
+                }
+                if (isEmpty(field === null || field === void 0 ? void 0 : field.type)) {
+                    errors.push(`settings.fields[${fieldLabel}]: 'type' is required for each field object.`);
+                }
+            });
+        }
+        // ── Rule: enablePermission / enableReadPermission / enableWritePermission ──
+        // If enablePermission is true  → at least one of enableReadPermission or enableWritePermission must be true.
+        // If enablePermission is false → both enableReadPermission and enableWritePermission must be false.
+        if ('enablePermission' in settings) {
+            const enablePermission = settings.enablePermission;
+            const enableReadPermission = settings.enableReadPermission;
+            const enableWritePermission = settings.enableWritePermission;
+            if (enablePermission === true) {
+                if (enableReadPermission !== true && enableWritePermission !== true) {
+                    errors.push("settings: 'enablePermission' is true, so at least one of " +
+                        "'enableReadPermission' or 'enableWritePermission' must also be true.");
+                }
+            }
+            else if (enablePermission === false) {
+                if (enableReadPermission === true) {
+                    errors.push("settings: 'enableReadPermission' must be false when 'enablePermission' is false.");
+                }
+                if (enableWritePermission === true) {
+                    errors.push("settings: 'enableWritePermission' must be false when 'enablePermission' is false.");
+                }
+            }
+        }
+        // If 'oauth' property is present in manifest → settings.fields must have at least one type "OAuth" field
+        if ('oauth' in manifest) {
+            const fields = Array.isArray(settings.fields) ? settings.fields : [];
+            const hasOAuthField = fields.some((field) => field && typeof field.type === 'string' && field.type.toLowerCase() === 'oauth');
+            if (!hasOAuthField) {
+                errors.push("settings.fields must contain at least one field with type 'OAuth' when oauth is configured. " +
+                    'Example: { "key": "token", "type": "OAuth", "secure": true, "required": true, ... }');
+            }
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`Validation errors in ${manifestPath}:\n  - ${errors.join('\n  - ')}`);
+    }
+}

package/dist/utils/appConfig.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllConfigs = getAllConfigs;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function getAllConfigs(appPath) {
+    // Look for a config file (config.json or app.config.json). Return parsed object or empty.
+    const candidates = ['config.json', 'app.config.json'];
+    for (const c of candidates) {
+        const p = path_1.default.join(appPath, c);
+        if (fs_1.default.existsSync(p)) {
+            try {
+                return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+            }
+            catch (e) {
+                return {};
+            }
+        }
+    }
+    return {};
+}

package/dist/utils/createApp.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAppPkg = uploadAppPkg;
+exports.deployApp = deployApp;
+exports.createProductInstallation = createProductInstallation;
+const fs_1 = __importDefault(require("fs"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const form_data_1 = __importDefault(require("form-data"));
+async function uploadAppPkg(apiUrl, apiToken, pkgPath) {
+    const form = new form_data_1.default();
+    form.append('file', fs_1.default.createReadStream(pkgPath));
+    const headers = form.getHeaders();
+    headers['Authorization'] = `Bearer ${apiToken}`;
+    const res = await (0, node_fetch_1.default)(`${apiUrl.replace(/\/+$/, '')}/apps/upload`, {
+        method: 'POST',
+        headers,
+        body: form
+    });
+    if (!res.ok)
+        throw new Error(`Upload failed: ${res.status} ${res.statusText}`);
+    return res.json();
+}
+async function deployApp(apiUrl, apiToken, uploadId, name) {
+    const res = await (0, node_fetch_1.default)(`${apiUrl.replace(/\/+$/, '')}/apps/deploy`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiToken}`
+        },
+        body: JSON.stringify({ upload_id: uploadId, name })
+    });
+    if (!res.ok)
+        throw new Error(`Deploy request failed: ${res.status} ${res.statusText}`);
+    return res.json();
+}
+async function createProductInstallation(apiUrl, apiToken, settings, manifest, appId, product) {
+    const url = `${apiUrl.replace(/\/+$/, '')}/products/${encodeURIComponent(product)}/installations`;
+    const res = await (0, node_fetch_1.default)(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiToken}` },
+        body: JSON.stringify({ app_id: appId, settings, manifest })
+    });
+    return res.ok;
+}

package/dist/utils/getAppSettings.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppSettings = getAppSettings;
+async function getAppSettings(manifest, configParams = {}) {
+    const params = manifest.parameters || {};
+    const settings = {};
+    for (const [k, v] of Object.entries(params)) {
+        // prefer configParams value, otherwise manifest default, otherwise empty string
+        // @ts-ignore
+        settings[k] = (configParams && configParams[k] !== undefined) ? configParams[k] : ((v && v.default) ? v.default : '');
+    }
+    return settings;
+}

package/dist/utils/manifest.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManifestFile = getManifestFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function getManifestFile(appPath) {
+    const manifestPath = path_1.default.resolve(appPath, 'manifest.json');
+    if (!fs_1.default.existsSync(manifestPath))
+        throw new Error(`manifest.json not found in ${appPath}`);
+    return JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+}

package/dist/utils/uploadApp.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUploadJobStatus = getUploadJobStatus;
+async function getUploadJobStatus(apiUrl, apiToken, jobId, timeoutMs = 2 * 60 * 1000) {
+    const start = Date.now();
+    while (true) {
+        const res = await fetch(`${apiUrl.replace(/\/+$/, '')}/jobs/${jobId}`, {
+            method: 'GET',
+            headers: { 'Authorization': `Bearer ${apiToken}` }
+        });
+        if (!res.ok)
+            throw new Error(`Job status request failed: ${res.status} ${res.statusText}`);
+        const body = await res.json();
+        const status = body.status || body.state || '';
+        if (status === 'success' || status === 'completed' || status === 'ok') {
+            return body;
+        }
+        if (status === 'failed' || status === 'error') {
+            throw new Error(`Job failed: ${JSON.stringify(body)}`);
+        }
+        if (Date.now() - start > timeoutMs)
+            throw new Error('Timed out waiting for job to complete');
+        await new Promise((r) => setTimeout(r, 2000));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-bdk-cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "test CLI",
   "author": "@BoldDesk",
   "bin": {
@@ -9,7 +9,8 @@
   "npmRegistry": "https://registry.npmjs.org",
   "license": "MIT",
   "scripts": {
-    "build": "npx tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json",
+    "prepare": "tsc -p tsconfig.json",
     "dev": "ts-node src/index.ts",
     "start": "node dist/index.js",
     "test": "jest"