at-builder 1.2.9 → 1.4.0

package/bin/index.js

@@ -1,22 +1,78 @@
 #!/usr/bin/env node
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const config_1 = require("./constants/config");
-const doctor_1 = require("./services/doctor");
-const logger_1 = __importDefault(require("./services/logger"));
+var child_process_1 = require("child_process");
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+var commander_1 = require("commander");
+var config_1 = require("./constants/config");
+var doctor_1 = require("./services/doctor");
+var logger_1 = __importDefault(require("./services/logger"));
 /**
  * Checks if the .env file exists at the current working directory
  *
  * @throws {Error} If the .env file is not found
  */
-const checkEnvFile = () => {
+var checkEnvFile = function () {
     logger_1.default.info("checkEnvFile", "Checking if .env file exists at current working directory");
     try {
         // Check if the file exists and is readable
@@ -25,94 +81,197 @@ const checkEnvFile = () => {
     }
     catch (error) {
         // If the file does not exist, provide helpful guidance
-        console.error('\x1b[31m%s\x1b[0m', `❌ Error: .env file not found at ${process.cwd()}`);
+        console.error('\x1b[31m%s\x1b[0m', "\u274C Error: .env file not found at ".concat(process.cwd()));
         console.error('\x1b[33m%s\x1b[0m', '💡 Run "atb init" to create .env file or "atb doctor --fix" to diagnose and fix configuration issues.');
-        logger_1.default.error("checkEnvFile", `Error: Couldn't find .env file at location ${process.cwd()}`);
+        logger_1.default.error("checkEnvFile", "Error: Couldn't find .env file at location ".concat(process.cwd()));
         throw error;
     }
 };
 // Prepare environment for spawning processes
-const productionEnv = {
-    ...process.env,
-    executionPath: process.cwd()
-};
+var productionEnv = __assign(__assign({}, process.env), { executionPath: process.cwd() });
 // Commander setup with proper subcommands
-const setupCommander = async () => {
-    logger_1.default.info("setupCommander", "Setting up commander");
-    const version = await (0, config_1.getVersion)();
-    const program = new commander_1.Command();
-    program
-        .name('atb')
-        .description('Adobe Target Activity Development CLI')
-        .version(version, "-V, --version")
-        .option("-v, --verbose", "Enable verbose logging");
-    // Add subcommands with proper actions
-    program
-        .command('init')
-        .description('Initialize project with .env configuration and templates')
-        .action(async (options, command) => {
-        const globalOpts = command.parent.opts();
-        await handleInit(globalOpts.verbose);
-    });
-    program
-        .command('new')
-        .description('Create a new Adobe Target activity with variations')
-        .action(async (options, command) => {
-        const globalOpts = command.parent.opts();
-        await handleNew(globalOpts.verbose);
-    });
-    program
-        .command('build')
-        .description('Build activity for development or production')
-        .option('--prod', 'Build for production deployment')
-        .action(async (options, command) => {
-        const globalOpts = command.parent.opts();
-        checkEnvFile();
-        await handleBuild(options.prod, globalOpts.verbose);
-    });
-    program
-        .command('dev')
-        .description('Start development server with file watching')
-        .option('--browser', 'Open in browser automatically')
-        .action(async (options, command) => {
-        const globalOpts = command.parent.opts();
-        checkEnvFile();
-        await handleDev(options.browser, globalOpts.verbose);
-    });
-    program
-        .command('deploy')
-        .description('Deploy activity to Adobe Target using at-deploy.js')
-        .option('--dry-run', 'Run deployment in dry-run mode without actual deployment')
-        .action(async (options, command) => {
-        const globalOpts = command.parent.opts();
-        checkEnvFile();
-        await handleDeploy(options.dryRun, globalOpts.verbose);
-    });
-    program
-        .command('doctor')
-        .description('Diagnose and fix project configuration issues')
-        .option('--fix', 'Automatically fix detected issues')
-        .action(async (options, command) => {
-        const globalOpts = command.parent.opts();
-        await handleDoctor(options.fix, globalOpts.verbose);
+var setupCommander = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var version, program;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                logger_1.default.info("setupCommander", "Setting up commander");
+                return [4 /*yield*/, (0, config_1.getVersion)()];
+            case 1:
+                version = _a.sent();
+                program = new commander_1.Command();
+                program
+                    .name('atb')
+                    .description('Adobe Target Activity Development CLI')
+                    .version(version, "-V, --version")
+                    .option("-v, --verbose", "Enable verbose logging");
+                // Add subcommands with proper actions
+                program
+                    .command('init')
+                    .description('Initialize project with .env configuration and templates')
+                    .action(function (options, command) { return __awaiter(void 0, void 0, void 0, function () {
+                    var globalOpts;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                globalOpts = command.parent.opts();
+                                return [4 /*yield*/, handleInit(globalOpts.verbose)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                program
+                    .command('new')
+                    .description('Create a new Adobe Target activity with variations')
+                    .action(function (options, command) { return __awaiter(void 0, void 0, void 0, function () {
+                    var globalOpts;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                globalOpts = command.parent.opts();
+                                return [4 /*yield*/, handleNew(globalOpts.verbose)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                program
+                    .command('build')
+                    .description('Build activity for development or production')
+                    .option('--prod', 'Build for production deployment')
+                    .action(function (options, command) { return __awaiter(void 0, void 0, void 0, function () {
+                    var globalOpts;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                globalOpts = command.parent.opts();
+                                checkEnvFile();
+                                return [4 /*yield*/, handleBuild(options.prod, globalOpts.verbose)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                program
+                    .command('dev')
+                    .description('Start development server with file watching')
+                    .option('--browser', 'Open in browser automatically')
+                    .action(function (options, command) { return __awaiter(void 0, void 0, void 0, function () {
+                    var globalOpts;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                globalOpts = command.parent.opts();
+                                checkEnvFile();
+                                return [4 /*yield*/, handleDev(options.browser, globalOpts.verbose)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                program
+                    .command('deploy')
+                    .description('Deploy activity to Adobe Target using at-deploy.js')
+                    .option('--dry-run', 'Run deployment in dry-run mode without actual deployment')
+                    .option('--force', 'Override the 60s post-deploy cooldown lock')
+                    .action(function (options, command) { return __awaiter(void 0, void 0, void 0, function () {
+                    var globalOpts;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                globalOpts = command.parent.opts();
+                                checkEnvFile();
+                                return [4 /*yield*/, handleDeploy(options.dryRun, options.force, globalOpts.verbose)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                program
+                    .command('sync')
+                    .description('Sync build.config.json with the Adobe Target activity definition')
+                    .option('--scaffold', 'Auto-create missing variation folders with boilerplate')
+                    .action(function (options, command) { return __awaiter(void 0, void 0, void 0, function () {
+                    var globalOpts;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                globalOpts = command.parent.opts();
+                                checkEnvFile();
+                                return [4 /*yield*/, handleSync(options.scaffold, globalOpts.verbose)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                program
+                    .command('doctor')
+                    .description('Diagnose and fix project configuration issues')
+                    .option('--fix', 'Automatically fix detected issues')
+                    .action(function (options, command) { return __awaiter(void 0, void 0, void 0, function () {
+                    var globalOpts;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                globalOpts = command.parent.opts();
+                                return [4 /*yield*/, handleDoctor(options.fix, globalOpts.verbose)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                program
+                    .command('install-extension')
+                    .description('Install the bundled at-builder VSCode extension (.vsix)')
+                    .option('--editor <bin>', 'Editor CLI to use (e.g. code, cursor, codium)', 'code')
+                    .action(function (options, command) { return __awaiter(void 0, void 0, void 0, function () {
+                    var globalOpts;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                globalOpts = command.parent.opts();
+                                return [4 /*yield*/, handleInstallExtension(options.editor, globalOpts.verbose)];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                return [4 /*yield*/, program.parseAsync(process.argv)];
+            case 2:
+                _a.sent();
+                logger_1.default.info("setupCommander", "Commander setup complete");
+                return [2 /*return*/];
+        }
     });
-    await program.parseAsync(process.argv);
-    logger_1.default.info("setupCommander", "Commander setup complete");
-};
+}); };
 /**
  * Spawn a command using `npm` with the given command array and environment object.
  *
+ * Any entries in `scriptArgs` are forwarded to the underlying script via npm's
+ * `--` passthrough (e.g. `npm run foo -- --dry-run`).
+ *
  * @param commandArr - The array of command strings to pass to `npm`.
  * @param env - The environment object to pass to the spawned process.
+ * @param scriptArgs - Optional flags/args to forward to the npm script itself.
  */
-const runCommand = (commandArr, env) => {
-    logger_1.default.info("runCommand", `Running npm command [${commandArr.join(", ")}]`);
-    logger_1.default.info("runCommand", `Current working directory: ${process.cwd()}`);
-    // logger.log(`Environment variables: ${JSON.stringify(env, null, 2)}`);
-    // Spawn the command using `npm` with the given environment and current working directory.
-    (0, child_process_1.spawn)("npm", commandArr, {
+var runCommand = function (commandArr, env, scriptArgs) {
+    if (scriptArgs === void 0) { scriptArgs = []; }
+    var fullArgs = scriptArgs.length > 0
+        ? __spreadArray(__spreadArray(__spreadArray([], commandArr, true), ["--"], false), scriptArgs, true) : commandArr;
+    logger_1.default.info("runCommand", "Running npm command [".concat(fullArgs.join(", "), "]"));
+    logger_1.default.info("runCommand", "Current working directory: ".concat(process.cwd()));
+    (0, child_process_1.spawn)("npm", fullArgs, {
         cwd: path_1.default.join(__dirname, "../"),
-        env,
+        env: env,
         shell: true,
         stdio: "inherit",
     });
@@ -120,134 +279,287 @@ const runCommand = (commandArr, env) => {
 /**
  * Handles the init command
  */
-const handleInit = async (verbose) => {
-    if (verbose)
-        logger_1.default.info("verbose", "Initializing new .env file");
-    // Run npm init in the current working directory (where user ran atb init)
-    (0, child_process_1.spawn)("npm", ["init", "-y"], {
-        cwd: process.cwd(),
-        env: process.env,
-        shell: true,
-        stdio: "inherit",
-    });
-    // Install @babel/runtime as dev dependency in the current directory
-    (0, child_process_1.spawn)("npm", ["install", "@babel/runtime", "-D"], {
-        cwd: process.cwd(),
-        env: process.env,
-        shell: true,
-        stdio: "inherit",
+var handleInit = function (verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (verbose)
+            logger_1.default.info("verbose", "Initializing new .env file");
+        // Run npm init in the current working directory (where user ran atb init)
+        (0, child_process_1.spawn)("npm", ["init", "-y"], {
+            cwd: process.cwd(),
+            env: process.env,
+            shell: true,
+            stdio: "inherit",
+        });
+        // Install @babel/runtime as dev dependency in the current directory
+        (0, child_process_1.spawn)("npm", ["install", "@babel/runtime", "-D"], {
+            cwd: process.cwd(),
+            env: process.env,
+            shell: true,
+            stdio: "inherit",
+        });
+        (0, config_1.setupEnv)(process.cwd());
+        return [2 /*return*/];
     });
-    (0, config_1.setupEnv)(process.cwd());
-};
+}); };
 /**
  * Handles the new command
  */
-const handleNew = async (verbose) => {
-    if (verbose)
-        logger_1.default.info("verbose", "Creating new activity");
-    runCommand(["run", "atb:plop:new:activity"], productionEnv);
-};
+var handleNew = function (verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (verbose)
+            logger_1.default.info("verbose", "Creating new activity");
+        runCommand(["run", "atb:plop:new:activity"], productionEnv);
+        return [2 /*return*/];
+    });
+}); };
 /**
  * Handles the build command
  */
-const handleBuild = async (prod, verbose) => {
-    if (verbose)
-        logger_1.default.info("verbose", `Building in ${prod ? 'production' : 'development'} mode`);
-    if (prod) {
-        process.env['NODE_ENV'] = 'production';
-        logger_1.default.info("handleBuild", "Running build with production environment");
-        runCommand(['run', 'atb:build:prod'], productionEnv);
-    }
-    else {
-        logger_1.default.info("handleBuild", "Running build with development environment");
-        runCommand(['run', 'atb:build:dev'], productionEnv);
-    }
-};
+var handleBuild = function (prod, verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        if (verbose)
+            logger_1.default.info("verbose", "Building in ".concat(prod ? 'production' : 'development', " mode"));
+        if (prod) {
+            process.env['NODE_ENV'] = 'production';
+            logger_1.default.info("handleBuild", "Running build with production environment");
+            runCommand(['run', 'atb:build:prod'], productionEnv);
+        }
+        else {
+            logger_1.default.info("handleBuild", "Running build with development environment");
+            runCommand(['run', 'atb:build:dev'], productionEnv);
+        }
+        return [2 /*return*/];
+    });
+}); };
 /**
  * Handles the dev command
  */
-const handleDev = async (browser, verbose) => {
-    if (verbose)
-        logger_1.default.info("verbose", `Starting development server with browser=${browser}`);
-    const commandArr = ['run', browser ? 'atb:build:dev:puppeteer' : 'atb:build:dev'];
-    logger_1.default.info("handleDev", `Running command: ${commandArr.join(', ')}`);
-    runCommand(commandArr, productionEnv);
-};
+var handleDev = function (browser, verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    var commandArr;
+    return __generator(this, function (_a) {
+        if (verbose)
+            logger_1.default.info("verbose", "Starting development server with browser=".concat(browser));
+        commandArr = ['run', browser ? 'atb:build:dev:puppeteer' : 'atb:build:dev'];
+        logger_1.default.info("handleDev", "Running command: ".concat(commandArr.join(', ')));
+        runCommand(commandArr, productionEnv);
+        return [2 /*return*/];
+    });
+}); };
 /**
  * Handles the deploy command
  */
-const handleDeploy = async (dryRun, verbose) => {
-    if (verbose)
-        logger_1.default.info("verbose", `Deploying to Adobe Target with dry-run=${dryRun}`);
-    logger_1.default.info("handleDeploy", "Running Adobe Target deployment");
-    runCommand(['run', 'atb:build:deploy'], productionEnv);
-};
+var handleDeploy = function (dryRun, force, verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    var scriptArgs;
+    return __generator(this, function (_a) {
+        if (verbose)
+            logger_1.default.info("verbose", "Deploying to Adobe Target with dry-run=".concat(dryRun, " force=").concat(force));
+        logger_1.default.info("handleDeploy", "Running Adobe Target deployment");
+        scriptArgs = [];
+        if (dryRun)
+            scriptArgs.push('--dry-run');
+        if (force)
+            scriptArgs.push('--force');
+        runCommand(['run', 'atb:build:deploy'], productionEnv, scriptArgs);
+        return [2 /*return*/];
+    });
+}); };
 /**
- * Handles the doctor command
+ * Handles the sync command
  */
-const handleDoctor = async (autoFix, verbose) => {
-    if (verbose)
-        logger_1.default.info("verbose", `Running diagnostics with auto-fix=${autoFix}`);
-    logger_1.default.info("handleDoctor", "Diagnosing project configuration");
-    try {
-        // Run diagnostics
-        const issues = await (0, doctor_1.runDiagnostics)(process.cwd(), verbose);
-        if (issues.length === 0) {
-            console.log("✅ No issues found. Your project configuration is healthy!");
-            return;
+var handleSync = function (scaffold, verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    var scriptArgs;
+    return __generator(this, function (_a) {
+        if (verbose)
+            logger_1.default.info("verbose", "Syncing build.config.json with scaffold=".concat(scaffold));
+        logger_1.default.info("handleSync", "Running Adobe Target sync");
+        scriptArgs = [];
+        if (scaffold)
+            scriptArgs.push('--scaffold');
+        runCommand(['run', 'atb:build:sync'], productionEnv, scriptArgs);
+        return [2 /*return*/];
+    });
+}); };
+/**
+ * Handles the install-extension command.
+ *
+ * Locates the bundled at-builder-*.vsix in at-builder's install directory
+ * (one level up from this compiled file) and installs it via the editor's
+ * CLI. Defaults to `code`; users on Cursor/VSCodium can pass --editor.
+ *
+ * The .vsix lives inside the at-builder package itself, NOT the consumer's
+ * project — so it resolves via __dirname, not PWD.
+ */
+var handleInstallExtension = function (editor, verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    var installRoot, candidates, vsixPath, result;
+    return __generator(this, function (_a) {
+        if (verbose)
+            logger_1.default.info("verbose", "Installing VSCode extension via ".concat(editor));
+        installRoot = path_1.default.join(__dirname, "..");
+        try {
+            candidates = fs_1.default.readdirSync(installRoot)
+                .filter(function (f) { return /^at-builder-.+\.vsix$/.test(f); })
+                .sort()
+                .reverse(); // latest version first by lexicographic sort
+        }
+        catch (error) {
+            console.error("\u274C Failed to scan at-builder directory: ".concat(error.message));
+            process.exit(1);
+        }
+        if (candidates.length === 0) {
+            console.error("❌ No at-builder VSCode extension (.vsix) found bundled with this install.");
+            console.error("\uD83D\uDCA1 Expected at: ".concat(installRoot, "/at-builder-*.vsix"));
+            process.exit(1);
         }
-        // Display issues
-        console.log(`\n🔍 Found ${issues.length} issue(s):\n`);
-        issues.forEach((issue, index) => {
-            console.log(`${index + 1}. ${issue.severity === 'error' ? '❌' : '⚠️'} ${issue.message}`);
-            if (issue.suggestion) {
-                console.log(`   💡 ${issue.suggestion}`);
+        vsixPath = path_1.default.join(installRoot, candidates[0]);
+        console.log("\uD83D\uDCE6 Installing ".concat(candidates[0], " via \"").concat(editor, "\"..."));
+        result = (0, child_process_1.spawn)(editor, ["--install-extension", vsixPath], {
+            stdio: "inherit",
+            shell: true
+        });
+        result.on("error", function (err) {
+            // ENOENT here means the editor binary isn't on PATH.
+            if (err.code === "ENOENT") {
+                console.error("\u274C \"".concat(editor, "\" CLI not found in PATH."));
+                if (editor === "code") {
+                    console.error("💡 Open VSCode and run Command Palette → \"Shell Command: Install 'code' command in PATH\".");
+                }
+                else {
+                    console.error("\uD83D\uDCA1 Make sure the \"".concat(editor, "\" CLI is installed and on your PATH, or pass a different --editor."));
+                }
+            }
+            else {
+                console.error("\u274C Failed to launch \"".concat(editor, "\": ").concat(err.message));
             }
+            process.exit(1);
         });
-        if (autoFix) {
-            console.log('\n🔧 Attempting to fix issues...\n');
-            const fixed = await (0, doctor_1.fixIssues)(issues, process.cwd(), verbose);
-            console.log(`\n✅ Fixed ${fixed} issue(s).`);
-            if (fixed < issues.length) {
-                console.log(`⚠️ ${issues.length - fixed} issue(s) require manual attention.`);
+        result.on("exit", function (code) {
+            if (code === 0) {
+                console.log("✅ Extension installed. Reload your editor window to activate.");
+                return;
             }
+            // 127 = shell's "command not found". With shell:true the spawn 'error'
+            // event never fires for missing CLIs, so we surface the same hint here.
+            if (code === 127) {
+                console.error("\u274C \"".concat(editor, "\" CLI not found in PATH."));
+                if (editor === "code") {
+                    console.error("💡 Open VSCode and run Command Palette → \"Shell Command: Install 'code' command in PATH\".");
+                }
+                else {
+                    console.error("\uD83D\uDCA1 Make sure the \"".concat(editor, "\" CLI is installed and on your PATH, or pass a different --editor."));
+                }
+                process.exit(1);
+            }
+            console.error("\u274C \"".concat(editor, " --install-extension\" exited with code ").concat(code, "."));
+            process.exit(code !== null && code !== void 0 ? code : 1);
+        });
+        return [2 /*return*/];
+    });
+}); };
+/**
+ * Handles the doctor command
+ */
+var handleDoctor = function (autoFix, verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    var issues, fixed, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (verbose)
+                    logger_1.default.info("verbose", "Running diagnostics with auto-fix=".concat(autoFix));
+                logger_1.default.info("handleDoctor", "Diagnosing project configuration");
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 6, , 7]);
+                return [4 /*yield*/, (0, doctor_1.runDiagnostics)(process.cwd(), verbose)];
+            case 2:
+                issues = _a.sent();
+                if (issues.length === 0) {
+                    console.log("✅ No issues found. Your project configuration is healthy!");
+                    return [2 /*return*/];
+                }
+                // Display issues
+                console.log("\n\uD83D\uDD0D Found ".concat(issues.length, " issue(s):\n"));
+                issues.forEach(function (issue, index) {
+                    console.log("".concat(index + 1, ". ").concat(issue.severity === 'error' ? '❌' : '⚠️', " ").concat(issue.message));
+                    if (issue.suggestion) {
+                        console.log("   \uD83D\uDCA1 ".concat(issue.suggestion));
+                    }
+                });
+                if (!autoFix) return [3 /*break*/, 4];
+                console.log('\n🔧 Attempting to fix issues...\n');
+                return [4 /*yield*/, (0, doctor_1.fixIssues)(issues, process.cwd(), verbose)];
+            case 3:
+                fixed = _a.sent();
+                console.log("\n\u2705 Fixed ".concat(fixed, " issue(s)."));
+                if (fixed < issues.length) {
+                    console.log("\u26A0\uFE0F ".concat(issues.length - fixed, " issue(s) require manual attention."));
+                }
+                return [3 /*break*/, 5];
+            case 4:
+                console.log('\n💡 Run `atb doctor --fix` to automatically fix resolvable issues.');
+                _a.label = 5;
+            case 5: return [3 /*break*/, 7];
+            case 6:
+                error_1 = _a.sent();
+                logger_1.default.error("handleDoctor", "Doctor command failed: ".concat(error_1.message));
+                process.exit(1);
+                return [3 /*break*/, 7];
+            case 7: return [2 /*return*/];
         }
-        else {
-            console.log('\n💡 Run `atb doctor --fix` to automatically fix resolvable issues.');
-        }
-    }
-    catch (error) {
-        logger_1.default.error("handleDoctor", `Doctor command failed: ${error.message}`);
-        process.exit(1);
-    }
-};
+    });
+}); };
 // Command execution logic
 /**
  * Main command execution entry point
  */
-const executeCommand = async () => {
-    logger_1.default.info("executeCommand", "Entering executeCommand");
-    await setupCommander();
-    logger_1.default.info("executeCommand", "Exiting executeCommand");
-};
+var executeCommand = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                logger_1.default.info("executeCommand", "Entering executeCommand");
+                return [4 /*yield*/, setupCommander()];
+            case 1:
+                _a.sent();
+                logger_1.default.info("executeCommand", "Exiting executeCommand");
+                return [2 /*return*/];
+        }
+    });
+}); };
 // Print command help
-const printCommandHelp = async () => {
-    const help = await (0, config_1.getHelpInfo)();
-    console.log(help);
-    process.exit(0);
-};
+var printCommandHelp = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var help;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, config_1.getHelpInfo)()];
+            case 1:
+                help = _a.sent();
+                console.log(help);
+                process.exit(0);
+                return [2 /*return*/];
+        }
+    });
+}); };
 /**
  * Main program flow
  */
-const main = async () => {
-    try {
-        await executeCommand();
-    }
-    catch (error) {
-        logger_1.default.error("main", error.message);
-        process.exit(1);
-    }
-};
+var main = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var error_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, executeCommand()];
+            case 1:
+                _a.sent();
+                return [3 /*break*/, 3];
+            case 2:
+                error_2 = _a.sent();
+                logger_1.default.error("main", error_2.message);
+                process.exit(1);
+                return [3 /*break*/, 3];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
 // Print custom help if no arguments, otherwise let Commander.js handle everything
 if (process.argv.length <= 2) {
     printCommandHelp();