statusbar-quick-actions 0.0.10 → 0.0.11

package/out/extension.js

@@ -0,0 +1,1166 @@
+"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.StatusBarQuickActionsExtension = void 0;
+exports.activate = activate;
+exports.deactivate = deactivate;
+const vscode = __importStar(require("vscode"));
+const fs = __importStar(require("fs"));
+const configuration_1 = require("./configuration");
+const executor_1 = require("./executor");
+const theme_1 = require("./theme");
+const visibility_1 = require("./visibility");
+const material_icons_1 = require("./material-icons");
+const output_panel_1 = require("./output-panel");
+const preset_manager_1 = require("./preset-manager");
+const dynamic_label_1 = require("./dynamic-label");
+class StatusBarQuickActionsExtension {
+    context;
+    configManager;
+    commandExecutor;
+    themeManager;
+    visibilityManager;
+    materialIconManager;
+    outputPanelManager;
+    presetManager;
+    dynamicLabelManager;
+    buttonStates = new Map();
+    disposables = [];
+    editorChangeListener = null;
+    isActivated = false;
+    debugMode = false;
+    constructor(context) {
+        this.context = context;
+        this.configManager = new configuration_1.ConfigManager();
+        this.commandExecutor = new executor_1.CommandExecutor();
+        this.themeManager = new theme_1.ThemeManager();
+        this.debugMode = vscode.workspace
+            .getConfiguration("statusbarQuickActions.settings")
+            .get("debug", false);
+    }
+    debugLog(...args) {
+        if (this.debugMode) {
+            console.log("[StatusBar Quick Actions]", ...args);
+        }
+    }
+    async activate() {
+        if (this.isActivated) {
+            return;
+        }
+        try {
+            await this.initializeManagers();
+            this.registerCommands();
+            this.setupConfigurationWatching();
+            await this.loadConfiguration();
+            this.isActivated = true;
+            this.debugLog("Extension activated successfully");
+            setImmediate(() => {
+                this.showWelcomeMessageIfNeeded().catch((error) => {
+                    this.debugLog("Failed to show welcome message:", error);
+                });
+            });
+        }
+        catch (error) {
+            console.error("Failed to activate StatusBar Quick Actions extension:", error);
+            vscode.window.showErrorMessage(`Failed to activate StatusBar Quick Actions: ${error}`);
+        }
+    }
+    async showWelcomeMessageIfNeeded() {
+        if (!this.context.globalState.get("hasBeenActivated")) {
+            await this.showWelcomeMessage();
+            await this.context.globalState.update("hasBeenActivated", true);
+        }
+    }
+    deactivate() {
+        if (!this.isActivated) {
+            return;
+        }
+        this.disposables.forEach((disposable) => disposable.dispose());
+        this.buttonStates.clear();
+        if (this.outputPanelManager) {
+            this.outputPanelManager.dispose();
+        }
+        if (this.visibilityManager) {
+            this.visibilityManager.dispose();
+        }
+        if (this.presetManager) {
+            this.presetManager.dispose();
+        }
+        if (this.dynamicLabelManager) {
+            this.dynamicLabelManager.dispose();
+        }
+        this.isActivated = false;
+        this.debugLog("Extension deactivated");
+    }
+    async initializeManagers() {
+        try {
+            this.configManager.initialize(this.context);
+            this.debugLog("ConfigManager initialized");
+            const outputConfig = this.configManager.getConfigValue("settings.output", this.getDefaultOutputConfig());
+            const performanceConfig = this.configManager.getConfigValue("settings.performance", this.getDefaultPerformanceConfig());
+            await Promise.all([
+                this.themeManager.initialize(this.context).then(() => {
+                    this.debugLog("ThemeManager initialized");
+                }),
+                (async () => {
+                    this.dynamicLabelManager = new dynamic_label_1.DynamicLabelManager();
+                    await this.dynamicLabelManager.initialize();
+                    this.dynamicLabelManager.onLabelRefresh = (buttonId) => {
+                        this.refreshButtonLabel(buttonId);
+                    };
+                    this.debugLog("DynamicLabelManager initialized");
+                })(),
+            ]);
+            this.materialIconManager = new material_icons_1.MaterialIconManager();
+            this.outputPanelManager = new output_panel_1.OutputPanelManager(outputConfig);
+            this.visibilityManager = new visibility_1.VisibilityManager(performanceConfig.visibilityDebounceMs);
+            this.presetManager = new preset_manager_1.PresetManager();
+            this.presetManager.initialize(this.context);
+            this.debugLog("All synchronous managers initialized");
+            this.setupEditorChangeListener();
+            this.debugLog("Managers initialization complete");
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error("Failed to initialize managers:", errorMessage);
+            vscode.window.showErrorMessage(`StatusBar Quick Actions: Failed to initialize - ${errorMessage}`);
+            throw error;
+        }
+    }
+    registerCommands() {
+        this.disposables.push(vscode.commands.registerCommand("statusbarQuickActions.editButton", this.editButton.bind(this)));
+        this.disposables.push(vscode.commands.registerCommand("statusbarQuickActions.viewHistory", this.viewHistory.bind(this)));
+        this.disposables.push(vscode.commands.registerCommand("statusbarQuickActions.clearHistory", this.clearHistory.bind(this)));
+        this.disposables.push(vscode.commands.registerCommand("statusbarQuickActions.managePresets", this.managePresets.bind(this)));
+        this.disposables.push(vscode.commands.registerCommand("statusbarQuickActions.applyPreset", this.applyPresetCommand.bind(this)));
+        this.disposables.push(vscode.commands.registerCommand("statusbarQuickActions.saveAsPreset", this.saveAsPreset.bind(this)));
+        this.registerButtonCommands();
+    }
+    registerButtonCommands() {
+        const config = this.configManager.getConfig();
+        config.buttons.forEach((button) => {
+            const commandId = `statusbarQuickActions.execute_${button.id}`;
+            this.disposables.push(vscode.commands.registerCommand(commandId, () => this.executeButton(button.id)));
+        });
+    }
+    setupConfigurationWatching() {
+        this.disposables.push(this.configManager.onConfigurationChanged(async (newConfig) => {
+            this.debugMode = vscode.workspace
+                .getConfiguration("statusbarQuickActions.settings")
+                .get("debug", false);
+            this.debugLog("Configuration changed, updating buttons");
+            await this.updateConfiguration(newConfig);
+        }));
+    }
+    async loadConfiguration() {
+        const config = this.configManager.getConfig();
+        await this.updateConfiguration(config);
+    }
+    async updateConfiguration(config) {
+        this.debugLog("Updating configuration with buttons:", config.buttons.length);
+        if (this.debugMode) {
+            config.buttons.forEach((button, index) => {
+                this.debugLog(`Button ${index}: ${button.id} - ${button.text || "no text"}`, button);
+            });
+        }
+        const validation = this.configManager.validateConfig(config);
+        if (!validation.isValid) {
+            const errorMessage = `Invalid button configuration:\n${validation.errors.join("\n")}`;
+            console.error(errorMessage);
+            vscode.window.showErrorMessage(`StatusBar Quick Actions: Configuration validation failed. Check console for details.`);
+            const outputChannel = vscode.window.createOutputChannel("StatusBar Quick Actions - Errors");
+            outputChannel.appendLine("Configuration Validation Errors:");
+            validation.errors.forEach((error) => outputChannel.appendLine(`  - ${error}`));
+            outputChannel.show(true);
+        }
+        this.buttonStates.forEach((state) => {
+            state.item.dispose();
+        });
+        this.buttonStates.clear();
+        let createdCount = 0;
+        let failedCount = 0;
+        let disabledCount = 0;
+        const buttonCreationPromises = config.buttons.map(async (buttonConfig) => {
+            if (buttonConfig.enabled === false) {
+                this.debugLog(`Button ${buttonConfig.id} is disabled, skipping`);
+                disabledCount++;
+                return { created: false, disabled: true };
+            }
+            const created = await this.createStatusBarItem(buttonConfig);
+            return { created, disabled: false };
+        });
+        const results = await Promise.all(buttonCreationPromises);
+        results.forEach((result) => {
+            if (result.created) {
+                createdCount++;
+            }
+            else if (!result.disabled) {
+                failedCount++;
+            }
+        });
+        this.debugLog(`Created ${createdCount} buttons, ${failedCount} failed, ${disabledCount} disabled`);
+        if (createdCount === 0 && config.buttons.length > 0) {
+            vscode.window.showWarningMessage(`StatusBar Quick Actions: No buttons could be created. Check the output panel for errors.`);
+        }
+    }
+    async createStatusBarItem(buttonConfig) {
+        try {
+            this.debugLog(`Creating status bar item for button: ${buttonConfig.id}`);
+            if (!buttonConfig.id) {
+                const error = `Button ${buttonConfig.id || "unknown"} missing ID`;
+                this.debugLog(error);
+                throw new Error("Button ID is required");
+            }
+            if (!buttonConfig.text && !buttonConfig.icon) {
+                const error = `Button ${buttonConfig.id} missing both text and icon`;
+                this.debugLog(error);
+                throw new Error("Either button text or icon is required");
+            }
+            if (!buttonConfig.command) {
+                const error = `Button ${buttonConfig.id} missing command`;
+                this.debugLog(error);
+                throw new Error("Button command is required");
+            }
+            const alignment = buttonConfig.alignment === "left"
+                ? vscode.StatusBarAlignment.Left
+                : vscode.StatusBarAlignment.Right;
+            const priority = buttonConfig.priority ?? 100;
+            const statusBarItem = vscode.window.createStatusBarItem(alignment, priority);
+            this.debugLog(`Created status bar item for ${buttonConfig.id} (alignment: ${alignment}, priority: ${priority})`);
+            const displayText = this.getButtonDisplayText(buttonConfig);
+            this.debugLog(`Button ${buttonConfig.id} display text: "${displayText}"`);
+            if (!displayText || displayText.trim() === "") {
+                const error = `Button ${buttonConfig.id} has empty display text`;
+                this.debugLog(error);
+                throw new Error("Button display text cannot be empty");
+            }
+            statusBarItem.text = displayText;
+            statusBarItem.tooltip =
+                buttonConfig.tooltip || buttonConfig.text || "Quick Action";
+            statusBarItem.command = `statusbarQuickActions.execute_${buttonConfig.id}`;
+            this.debugLog(`Button ${buttonConfig.id} command: ${statusBarItem.command}`);
+            this.themeManager.applyThemeToStatusBarItem(statusBarItem);
+            statusBarItem.accessibilityInformation = {
+                label: buttonConfig.tooltip ||
+                    buttonConfig.text ||
+                    `Button ${buttonConfig.id}`,
+                role: "button",
+            };
+            const buttonState = {
+                item: statusBarItem,
+                config: buttonConfig,
+                isExecuting: false,
+                history: [],
+                accessibility: {
+                    role: "button",
+                    ariaLabel: buttonConfig.tooltip ||
+                        buttonConfig.text ||
+                        `Button ${buttonConfig.id}`,
+                    focusOrder: priority,
+                },
+            };
+            this.buttonStates.set(buttonConfig.id, buttonState);
+            this.disposables.push(statusBarItem);
+            statusBarItem.show();
+            setImmediate(() => {
+                this.loadHistoryAsync(buttonConfig.id).catch((error) => {
+                    this.debugLog(`Failed to load history for ${buttonConfig.id}:`, error);
+                });
+                if (buttonConfig.dynamicLabel) {
+                    this.refreshButtonLabel(buttonConfig.id).catch((error) => {
+                        this.debugLog(`Failed to refresh label for ${buttonConfig.id}:`, error);
+                    });
+                }
+            });
+            this.debugLog(`Button ${buttonConfig.id} created and shown`);
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to create statusbar item for button ${buttonConfig.id}:`, errorMessage);
+            vscode.window.showErrorMessage(`Failed to create button "${buttonConfig.text || buttonConfig.id}": ${errorMessage}`);
+            return false;
+        }
+    }
+    getButtonDisplayText(buttonConfig) {
+        if (buttonConfig.icon) {
+            const resolvedIconId = this.materialIconManager.resolveIcon(buttonConfig.icon);
+            const iconPrefix = buttonConfig.icon.animation === "spin"
+                ? `$(${resolvedIconId}~spin)`
+                : buttonConfig.icon.animation === "pulse"
+                    ? `$(${resolvedIconId}~pulse)`
+                    : `$(${resolvedIconId})`;
+            return iconPrefix;
+        }
+        return buttonConfig.text;
+    }
+    async executeButton(buttonId) {
+        const buttonState = this.buttonStates.get(buttonId);
+        if (!buttonState || buttonState.isExecuting) {
+            return;
+        }
+        const config = buttonState.config;
+        try {
+            buttonState.isExecuting = true;
+            this.updateButtonState(buttonId, buttonState);
+            if (config.execution?.showProgress) {
+                this.showProgress(buttonId);
+            }
+            const executionOptions = {
+                workingDirectory: config.workingDirectory,
+                environment: config.environment,
+            };
+            if (config.execution?.timeout) {
+                executionOptions.timeout = config.execution.timeout;
+            }
+            const outputConfig = this.outputPanelManager.getConfig();
+            if (outputConfig.enabled) {
+                this.outputPanelManager.getOrCreatePanel(buttonId, config.text);
+                if (outputConfig.clearOnRun) {
+                    this.outputPanelManager.clearPanel(buttonId);
+                }
+                executionOptions.streaming = {
+                    enabled: true,
+                    onStdout: (data) => {
+                        this.outputPanelManager.appendOutput(buttonId, data, "stdout");
+                    },
+                    onStderr: (data) => {
+                        this.outputPanelManager.appendOutput(buttonId, data, "stderr");
+                    },
+                };
+                this.outputPanelManager.showPanel(buttonId, true);
+            }
+            const result = await this.commandExecutor.execute(config.command, executionOptions);
+            buttonState.isExecuting = false;
+            buttonState.lastResult = result;
+            if (config.history?.enabled !== false) {
+                await this.addToHistory(buttonId, result);
+            }
+            this.updateButtonState(buttonId, buttonState);
+            await this.showExecutionResult(buttonId, result);
+        }
+        catch (error) {
+            buttonState.isExecuting = false;
+            this.updateButtonState(buttonId, buttonState);
+            const errorResult = {
+                code: -1,
+                stdout: "",
+                stderr: error instanceof Error ? error.message : String(error),
+                duration: 0,
+                timestamp: new Date(),
+                command: "Unknown",
+            };
+            buttonState.lastResult = errorResult;
+            this.updateButtonState(buttonId, buttonState);
+            await this.showExecutionError(buttonId, error);
+        }
+    }
+    updateButtonState(buttonId, buttonState) {
+        const config = buttonState.config;
+        if (buttonState.isExecuting) {
+            if (config.icon?.animation) {
+                buttonState.item.text =
+                    config.icon.animation === "spin"
+                        ? "$(sync~spin)"
+                        : config.icon.animation === "pulse"
+                            ? "$(sync~pulse)"
+                            : this.getButtonDisplayText(config);
+            }
+            else {
+                buttonState.item.text = `$(sync~spin) ${config.text}`;
+            }
+        }
+        else {
+            buttonState.item.text = this.getButtonDisplayText(config);
+        }
+        if (buttonState.lastResult) {
+            const result = buttonState.lastResult;
+            const status = result.code === 0 ? "✅" : "❌";
+            const duration = result.duration ? ` (${result.duration}ms)` : "";
+            buttonState.item.tooltip = `${config.tooltip || config.text}\n${status} Last run: ${result.timestamp.toLocaleTimeString()}${duration}`;
+        }
+        else {
+            buttonState.item.tooltip = config.tooltip || config.text;
+        }
+        buttonState.item.show();
+    }
+    showProgress(buttonId) {
+        const buttonState = this.buttonStates.get(buttonId);
+        if (!buttonState) {
+            return;
+        }
+        vscode.window.withProgress({
+            location: vscode.ProgressLocation.Notification,
+            title: `Executing: ${buttonState.config.text}`,
+            cancellable: false,
+        }, async (progress) => {
+            for (let i = 0; i <= 100; i += 10) {
+                if (!buttonState.isExecuting) {
+                    break;
+                }
+                progress.report({ increment: 10, message: `${i}%` });
+                await new Promise((resolve) => setTimeout(resolve, 200));
+            }
+        });
+    }
+    async showExecutionResult(buttonId, result) {
+        const buttonState = this.buttonStates.get(buttonId);
+        if (!buttonState) {
+            return;
+        }
+        const config = buttonState.config;
+        if (result.code === 0) {
+            const message = this.getResultMessage(result);
+            vscode.window
+                .showInformationMessage(`✅ ${config.text}: ${message}`, "View Output")
+                .then((selection) => {
+                if (selection === "View Output") {
+                    this.showOutput(result);
+                }
+            });
+        }
+    }
+    async showExecutionError(buttonId, error) {
+        const buttonState = this.buttonStates.get(buttonId);
+        if (!buttonState) {
+            return;
+        }
+        const config = buttonState.config;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        vscode.window
+            .showErrorMessage(`❌ ${config.text}: ${errorMessage}`, "View Details")
+            .then((selection) => {
+            if (selection === "View Details") {
+                vscode.window.showErrorMessage(errorMessage, { modal: true });
+            }
+        });
+    }
+    getResultMessage(result) {
+        const showTime = true;
+        const timeStr = showTime && result.duration ? ` in ${result.duration}ms` : "";
+        if (result.stdout && result.stdout.trim()) {
+            const output = result.stdout.trim().split("\n")[0];
+            return output.length > 100
+                ? `${output.substring(0, 100)}...${timeStr}`
+                : `${output}${timeStr}`;
+        }
+        return `Completed successfully${timeStr}`;
+    }
+    showOutput(result) {
+        const output = `Command Output:\n${result.stdout}\n\nErrors:\n${result.stderr}`;
+        vscode.window.showInformationMessage(output, { modal: true });
+    }
+    async editButton() {
+        const mainMenuItems = [
+            {
+                label: "$(add) Add New Button",
+                description: "Create a new status bar button",
+            },
+            {
+                label: "$(edit) Edit Existing Button",
+                description: "Modify an existing button configuration",
+            },
+            {
+                label: "$(trash) Delete Button",
+                description: "Remove a button from the status bar",
+            },
+            {
+                label: "$(copy) Duplicate Button",
+                description: "Create a copy of an existing button",
+            },
+            {
+                label: "$(sync) Toggle Button",
+                description: "Enable or disable a button",
+            },
+            {
+                label: "$(archive) Manage Presets",
+                description: "Save, load, or manage configuration presets",
+            },
+            {
+                label: "$(settings-gear) Open Full Settings",
+                description: "Open VS Code settings page",
+            },
+            {
+                label: "$(export) Export Configuration",
+                description: "Export all button configurations to a file",
+            },
+            {
+                label: "$(import) Import Configuration",
+                description: "Import button configurations from a file",
+            },
+        ];
+        const selected = await vscode.window.showQuickPick(mainMenuItems, {
+            placeHolder: "StatusBar Quick Actions - Settings",
+            matchOnDescription: true,
+        });
+        if (!selected) {
+            return;
+        }
+        switch (selected.label) {
+            case "$(add) Add New Button":
+                await this.addNewButton();
+                break;
+            case "$(edit) Edit Existing Button":
+                await this.selectAndEditButton();
+                break;
+            case "$(trash) Delete Button":
+                await this.deleteButton();
+                break;
+            case "$(copy) Duplicate Button":
+                await this.duplicateButton();
+                break;
+            case "$(sync) Toggle Button":
+                await this.toggleButton();
+                break;
+            case "$(archive) Manage Presets":
+                await this.managePresets();
+                break;
+            case "$(settings-gear) Open Full Settings":
+                vscode.commands.executeCommand("workbench.action.openSettings", "@ext:involvex.statusbar-quick-actions");
+                break;
+            case "$(export) Export Configuration":
+                await this.exportConfiguration();
+                break;
+            case "$(import) Import Configuration":
+                await this.importConfiguration();
+                break;
+        }
+    }
+    async addNewButton() {
+        const text = await vscode.window.showInputBox({
+            prompt: "Enter button text (supports emojis)",
+            placeHolder: "e.g., Build 🔨",
+            validateInput: (value) => (value ? null : "Button text is required"),
+        });
+        if (!text) {
+            return;
+        }
+        const commandTypes = [
+            { label: "npm", description: "Run npm script" },
+            { label: "yarn", description: "Run yarn script" },
+            { label: "pnpm", description: "Run pnpm script" },
+            { label: "bun", description: "Run bun script" },
+            { label: "shell", description: "Run shell command" },
+            { label: "vscode", description: "Run VS Code command" },
+            { label: "task", description: "Run VS Code task" },
+            { label: "github", description: "Run GitHub CLI command" },
+            { label: "npx", description: "Run npx command" },
+            { label: "pnpx", description: "Run pnpx command" },
+            { label: "bunx", description: "Run bunx command" },
+            { label: "detect", description: "Auto-detect package manager" },
+        ];
+        const commandType = await vscode.window.showQuickPick(commandTypes, {
+            placeHolder: "Select command type",
+        });
+        if (!commandType) {
+            return;
+        }
+        const command = await vscode.window.showInputBox({
+            prompt: commandType.label === "npm" ||
+                commandType.label === "yarn" ||
+                commandType.label === "pnpm" ||
+                commandType.label === "bun" ||
+                commandType.label === "npx" ||
+                commandType.label === "pnpx" ||
+                commandType.label === "bunx" ||
+                commandType.label === "detect"
+                ? "Enter script name"
+                : "Enter command",
+            placeHolder: commandType.label === "npm" ? "e.g., build" : 'e.g., echo "Hello"',
+            validateInput: (value) => (value ? null : "Command is required"),
+        });
+        if (!command) {
+            return;
+        }
+        const id = `button_${Date.now()}`;
+        const newButton = {
+            id,
+            text,
+            tooltip: text,
+            command: {
+                type: commandType.label,
+                script: [
+                    "npm",
+                    "yarn",
+                    "pnpm",
+                    "bun",
+                    "bunx",
+                    "npx",
+                    "pnpx",
+                    "detect",
+                ].includes(commandType.label)
+                    ? command
+                    : undefined,
+                command: ![
+                    "npm",
+                    "yarn",
+                    "pnpm",
+                    "bun",
+                    "bunx",
+                    "npx",
+                    "pnpx",
+                    "detect",
+                ].includes(commandType.label)
+                    ? command
+                    : undefined,
+            },
+            enabled: true,
+            alignment: "left",
+            priority: 100,
+        };
+        const config = this.configManager.getConfig();
+        config.buttons.push(newButton);
+        await this.configManager.setConfig("buttons", config.buttons);
+        vscode.window.showInformationMessage(`✅ Button "${text}" added successfully!`);
+    }
+    async selectAndEditButton() {
+        const config = this.configManager.getConfig();
+        if (config.buttons.length === 0) {
+            vscode.window.showInformationMessage("No buttons configured yet.");
+            return;
+        }
+        const items = config.buttons.map((button) => ({
+            label: button.text,
+            description: button.command.type,
+            detail: button.tooltip,
+            button: button,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select a button to edit",
+        });
+        if (selected) {
+            vscode.commands.executeCommand("workbench.action.openSettings", `@ext:involvex.statusbar-quick-actions buttons`);
+        }
+    }
+    async deleteButton() {
+        const config = this.configManager.getConfig();
+        if (config.buttons.length === 0) {
+            vscode.window.showInformationMessage("No buttons configured yet.");
+            return;
+        }
+        const items = config.buttons.map((button) => ({
+            label: button.text,
+            description: button.command.type,
+            detail: button.id,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select a button to delete",
+        });
+        if (!selected) {
+            return;
+        }
+        const confirm = await vscode.window.showWarningMessage(`Delete button "${selected.label}"?`, { modal: true }, "Yes, Delete", "No");
+        if (confirm === "Yes, Delete") {
+            const updatedButtons = config.buttons.filter((b) => b.id !== selected.detail);
+            await this.configManager.setConfig("buttons", updatedButtons);
+            vscode.window.showInformationMessage(`✅ Button "${selected.label}" deleted`);
+        }
+    }
+    async duplicateButton() {
+        const config = this.configManager.getConfig();
+        if (config.buttons.length === 0) {
+            vscode.window.showInformationMessage("No buttons configured yet.");
+            return;
+        }
+        const items = config.buttons.map((button) => ({
+            label: button.text,
+            description: button.command.type,
+            button: button,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select a button to duplicate",
+        });
+        if (!selected) {
+            return;
+        }
+        const newButton = {
+            ...selected.button,
+            id: `button_${Date.now()}`,
+            text: `${selected.button.text} (Copy)`,
+        };
+        config.buttons.push(newButton);
+        await this.configManager.setConfig("buttons", config.buttons);
+        vscode.window.showInformationMessage(`✅ Button duplicated successfully!`);
+    }
+    async toggleButton() {
+        const config = this.configManager.getConfig();
+        if (config.buttons.length === 0) {
+            vscode.window.showInformationMessage("No buttons configured yet.");
+            return;
+        }
+        const items = config.buttons.map((button) => ({
+            label: button.text,
+            description: button.enabled ? "$(check) Enabled" : "$(x) Disabled",
+            button: button,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select a button to toggle",
+        });
+        if (!selected) {
+            return;
+        }
+        const buttonIndex = config.buttons.findIndex((b) => b.id === selected.button.id);
+        config.buttons[buttonIndex].enabled = !config.buttons[buttonIndex].enabled;
+        await this.configManager.setConfig("buttons", config.buttons);
+        const status = config.buttons[buttonIndex].enabled ? "enabled" : "disabled";
+        vscode.window.showInformationMessage(`✅ Button "${selected.label}" ${status}`);
+    }
+    async exportConfiguration() {
+        const config = this.configManager.getConfig();
+        const uri = await vscode.window.showSaveDialog({
+            filters: { JSON: ["json"] },
+            defaultUri: vscode.Uri.file("statusbar-quick-actions-config.json"),
+        });
+        if (uri) {
+            fs.writeFileSync(uri.fsPath, JSON.stringify(config, null, 2));
+            vscode.window.showInformationMessage(`✅ Configuration exported to ${uri.fsPath}`);
+        }
+    }
+    async importConfiguration() {
+        const uri = await vscode.window.showOpenDialog({
+            filters: { JSON: ["json"] },
+            canSelectMany: false,
+        });
+        if (uri && uri[0]) {
+            try {
+                const content = fs.readFileSync(uri[0].fsPath, "utf8");
+                const importedConfig = JSON.parse(content);
+                const merge = await vscode.window.showQuickPick(["Replace All", "Merge with Existing"], { placeHolder: "Import mode" });
+                if (!merge) {
+                    return;
+                }
+                if (merge === "Replace All") {
+                    await this.configManager.setConfig("buttons", importedConfig.buttons || []);
+                }
+                else {
+                    const config = this.configManager.getConfig();
+                    const mergedButtons = [
+                        ...config.buttons,
+                        ...(importedConfig.buttons || []),
+                    ];
+                    await this.configManager.setConfig("buttons", mergedButtons);
+                }
+                vscode.window.showInformationMessage("✅ Configuration imported successfully!");
+            }
+            catch (error) {
+                vscode.window.showErrorMessage(`Failed to import configuration: ${error}`);
+            }
+        }
+    }
+    async addToHistory(buttonId, result) {
+        try {
+            const historyKey = `history_${buttonId}`;
+            const history = this.context.globalState.get(historyKey, []);
+            history.unshift(result);
+            const buttonState = this.buttonStates.get(buttonId);
+            const maxEntries = buttonState?.config.history?.maxEntries || 20;
+            while (history.length > maxEntries) {
+                history.pop();
+            }
+            await this.context.globalState.update(historyKey, history);
+            if (buttonState) {
+                buttonState.history = history;
+            }
+        }
+        catch (error) {
+            console.error(`Failed to add execution to history for button ${buttonId}:`, error);
+        }
+    }
+    async loadHistory(buttonId) {
+        try {
+            const historyKey = `history_${buttonId}`;
+            return this.context.globalState.get(historyKey, []);
+        }
+        catch (error) {
+            console.error(`Failed to load history for button ${buttonId}:`, error);
+            return [];
+        }
+    }
+    async loadHistoryAsync(buttonId) {
+        const buttonState = this.buttonStates.get(buttonId);
+        if (!buttonState) {
+            return;
+        }
+        const history = await this.loadHistory(buttonId);
+        buttonState.history = history;
+        this.debugLog(`History loaded for ${buttonId}: ${history.length} entries`);
+    }
+    async getAllHistory() {
+        const allHistory = new Map();
+        for (const [buttonId] of this.buttonStates) {
+            const history = await this.loadHistory(buttonId);
+            if (history.length > 0) {
+                allHistory.set(buttonId, history);
+            }
+        }
+        return allHistory;
+    }
+    async viewHistory() {
+        const allHistory = await this.getAllHistory();
+        if (allHistory.size === 0) {
+            vscode.window.showInformationMessage("No command history available yet.");
+            return;
+        }
+        const items = [];
+        for (const [buttonId, history] of allHistory) {
+            const buttonState = this.buttonStates.get(buttonId);
+            const buttonName = buttonState?.config.text || buttonId;
+            items.push({
+                label: `$(inbox) ${buttonName}`,
+                kind: vscode.QuickPickItemKind.Separator,
+            });
+            history.forEach((entry) => {
+                const status = entry.code === 0 ? "$(check)" : "$(error)";
+                const time = entry.timestamp.toLocaleString();
+                const duration = entry.duration ? ` (${entry.duration}ms)` : "";
+                items.push({
+                    label: `${status} ${entry.command}`,
+                    description: `${time}${duration}`,
+                    detail: entry.stderr || entry.stdout?.substring(0, 100),
+                    buttons: [
+                        {
+                            iconPath: new vscode.ThemeIcon("output"),
+                            tooltip: "View Full Output",
+                        },
+                    ],
+                });
+            });
+        }
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Command Execution History",
+            matchOnDescription: true,
+            matchOnDetail: true,
+        });
+        if (selected && selected.detail) {
+            const doc = await vscode.workspace.openTextDocument({
+                content: `Command: ${selected.label}\nTime: ${selected.description}\n\nOutput:\n${selected.detail}`,
+                language: "text",
+            });
+            await vscode.window.showTextDocument(doc);
+        }
+    }
+    async clearHistory() {
+        const confirm = await vscode.window.showWarningMessage("Are you sure you want to clear all command history?", { modal: true }, "Yes, Clear History", "No");
+        if (confirm === "Yes, Clear History") {
+            try {
+                for (const [buttonId, buttonState] of this.buttonStates) {
+                    const historyKey = `history_${buttonId}`;
+                    await this.context.globalState.update(historyKey, []);
+                    buttonState.history = [];
+                }
+                vscode.window.showInformationMessage("✅ Command history cleared successfully");
+            }
+            catch (error) {
+                vscode.window.showErrorMessage(`Failed to clear history: ${error}`);
+            }
+        }
+    }
+    async showWelcomeMessage() {
+        const config = this.configManager.getConfig();
+        if (config.buttons.length === 0) {
+            vscode.window
+                .showInformationMessage("👋 Welcome to StatusBar Quick Actions! Configure your first button in Settings.", "Open Settings")
+                .then((selection) => {
+                if (selection === "Open Settings") {
+                    vscode.commands.executeCommand("workbench.action.openSettings", "@ext:statusbar-quick-actions");
+                }
+            });
+        }
+    }
+    getDefaultOutputConfig() {
+        return {
+            enabled: true,
+            mode: "per-button",
+            format: "formatted",
+            clearOnRun: false,
+            showTimestamps: true,
+            preserveHistory: true,
+            maxLines: 1000,
+        };
+    }
+    getDefaultPerformanceConfig() {
+        return {
+            visibilityDebounceMs: 300,
+            enableVirtualization: false,
+            cacheResults: true,
+        };
+    }
+    setupEditorChangeListener() {
+        this.editorChangeListener = vscode.window.onDidChangeActiveTextEditor(() => {
+            this.buttonStates.forEach((buttonState, buttonId) => {
+                if (buttonState.config.visibility) {
+                    const customDebounce = buttonState.config.visibility.debounceMs;
+                    this.visibilityManager.checkVisibilityDebounced(buttonId, buttonState.config.visibility, customDebounce, (isVisible) => {
+                        if (isVisible) {
+                            buttonState.item.show();
+                        }
+                        else {
+                            buttonState.item.hide();
+                        }
+                    });
+                }
+            });
+        });
+        this.disposables.push(this.editorChangeListener);
+    }
+    async managePresets() {
+        const items = [
+            {
+                label: "$(add) Create New Preset",
+                description: "Save current configuration as a preset",
+            },
+            {
+                label: "$(archive) Apply Preset",
+                description: "Load a saved preset",
+            },
+            {
+                label: "$(list-unordered) View All Presets",
+                description: "Browse and manage saved presets",
+            },
+            {
+                label: "$(export) Export Preset",
+                description: "Export a preset to a file",
+            },
+            {
+                label: "$(import) Import Preset",
+                description: "Import a preset from a file",
+            },
+        ];
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Preset Management",
+            matchOnDescription: true,
+        });
+        if (!selected) {
+            return;
+        }
+        switch (selected.label) {
+            case "$(add) Create New Preset":
+                await this.saveAsPreset();
+                break;
+            case "$(archive) Apply Preset":
+                await this.applyPresetCommand();
+                break;
+            case "$(list-unordered) View All Presets":
+                await this.viewAllPresets();
+                break;
+            case "$(export) Export Preset":
+                await this.exportPresetCommand();
+                break;
+            case "$(import) Import Preset":
+                await this.importPresetCommand();
+                break;
+        }
+    }
+    async saveAsPreset() {
+        const name = await vscode.window.showInputBox({
+            prompt: "Enter preset name",
+            placeHolder: "e.g., My Development Setup",
+            validateInput: (value) => (value ? null : "Name is required"),
+        });
+        if (!name) {
+            return;
+        }
+        const description = await vscode.window.showInputBox({
+            prompt: "Enter preset description (optional)",
+            placeHolder: "e.g., Standard buttons for Node.js development",
+        });
+        try {
+            const currentConfig = this.configManager.getConfig();
+            await this.presetManager.createPresetFromConfig(name, description || "", currentConfig);
+            vscode.window.showInformationMessage(`✅ Preset "${name}" created successfully!`);
+        }
+        catch (error) {
+            vscode.window.showErrorMessage(`Failed to create preset: ${error}`);
+        }
+    }
+    async applyPresetCommand() {
+        const presets = this.presetManager.getAllPresets();
+        if (presets.length === 0) {
+            vscode.window.showInformationMessage("No presets available yet.");
+            return;
+        }
+        const items = presets.map((preset) => ({
+            label: preset.name,
+            description: preset.description,
+            detail: `${preset.buttons.length} buttons · Created ${preset.metadata?.created.toLocaleDateString()}`,
+            preset,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select a preset to apply",
+            matchOnDescription: true,
+            matchOnDetail: true,
+        });
+        if (!selected) {
+            return;
+        }
+        const modeItems = [
+            {
+                label: "Replace",
+                description: "Replace all current buttons with preset buttons",
+            },
+            {
+                label: "Merge",
+                description: "Merge preset buttons with current buttons (overwrite duplicates)",
+            },
+            {
+                label: "Append",
+                description: "Add preset buttons to current buttons",
+            },
+        ];
+        const modeSelected = await vscode.window.showQuickPick(modeItems, {
+            placeHolder: "How should the preset be applied?",
+        });
+        if (!modeSelected) {
+            return;
+        }
+        const mode = modeSelected.label.toLowerCase();
+        const impact = this.configManager.getPresetImpact(selected.preset, mode);
+        const confirm = await vscode.window.showWarningMessage(`Apply preset "${selected.preset.name}"?\n\nImpact:\n• ${impact.added} buttons added\n• ${impact.modified} buttons modified\n• ${impact.removed} buttons removed`, { modal: true }, "Yes, Apply", "No");
+        if (confirm !== "Yes, Apply") {
+            return;
+        }
+        try {
+            await this.configManager.applyPreset(selected.preset, mode);
+            vscode.window.showInformationMessage(`✅ Preset "${selected.preset.name}" applied successfully!`);
+        }
+        catch (error) {
+            vscode.window.showErrorMessage(`Failed to apply preset: ${error}`);
+        }
+    }
+    async viewAllPresets() {
+        const presets = this.presetManager.getAllPresets();
+        if (presets.length === 0) {
+            vscode.window.showInformationMessage("No presets available yet.");
+            return;
+        }
+        const items = presets.map((preset) => ({
+            label: preset.name,
+            description: `${preset.buttons.length} buttons`,
+            detail: preset.description,
+            buttons: [
+                {
+                    iconPath: new vscode.ThemeIcon("edit"),
+                    tooltip: "Rename Preset",
+                },
+                {
+                    iconPath: new vscode.ThemeIcon("copy"),
+                    tooltip: "Duplicate Preset",
+                },
+                {
+                    iconPath: new vscode.ThemeIcon("trash"),
+                    tooltip: "Delete Preset",
+                },
+            ],
+            preset,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Manage Presets",
+            matchOnDescription: true,
+            matchOnDetail: true,
+        });
+        if (selected) {
+            await this.applyPresetCommand();
+        }
+    }
+    async exportPresetCommand() {
+        const presets = this.presetManager.getAllPresets();
+        if (presets.length === 0) {
+            vscode.window.showInformationMessage("No presets available to export.");
+            return;
+        }
+        const items = presets.map((preset) => ({
+            label: preset.name,
+            description: `${preset.buttons.length} buttons`,
+            preset,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select a preset to export",
+        });
+        if (!selected) {
+            return;
+        }
+        try {
+            await this.presetManager.exportPreset(selected.preset);
+        }
+        catch (error) {
+            vscode.window.showErrorMessage(`Failed to export preset: ${error}`);
+        }
+    }
+    async importPresetCommand() {
+        try {
+            const preset = await this.presetManager.importPreset();
+            if (preset) {
+                const apply = await vscode.window.showInformationMessage(`Preset "${preset.name}" imported. Apply it now?`, "Yes", "No");
+                if (apply === "Yes") {
+                    await this.configManager.applyPreset(preset, "replace");
+                }
+            }
+        }
+        catch (error) {
+            vscode.window.showErrorMessage(`Failed to import preset: ${error}`);
+        }
+    }
+    async refreshButtonLabel(buttonId) {
+        const buttonState = this.buttonStates.get(buttonId);
+        if (!buttonState || !buttonState.config.dynamicLabel) {
+            return;
+        }
+        try {
+            const newLabel = await this.dynamicLabelManager.evaluateLabel(buttonId, buttonState.config.dynamicLabel);
+            if (buttonState.config.icon) {
+                const iconText = this.getButtonDisplayText(buttonState.config);
+                buttonState.item.text = `${iconText} ${newLabel}`;
+            }
+            else {
+                buttonState.item.text = newLabel;
+            }
+        }
+        catch (error) {
+            console.error(`Failed to refresh label for ${buttonId}:`, error);
+        }
+    }
+}
+exports.StatusBarQuickActionsExtension = StatusBarQuickActionsExtension;
+function activate(context) {
+    console.log("Activating StatusBar Quick Actions extension...");
+    const extension = new StatusBarQuickActionsExtension(context);
+    context.subscriptions.push({
+        dispose: () => extension.deactivate(),
+    });
+    extension.activate();
+}
+function deactivate() {
+    console.log("Deactivating StatusBar Quick Actions extension...");
+}