local-bdk-cli 1.0.7

package/README.md

@@ -0,0 +1,3 @@
+# BoldDesk App Template
+
+Minimal scaffold for BoldDesk apps. Use `bdk apps:new my-app` to scaffold a new project.

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 ─────────────────────────────────────────── */
+    });
+}