@choochmeque/tauri-windows-bundle 0.1.0

package/dist/cli.js

@@ -0,0 +1,1551 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { glob } from 'glob';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import * as readline from 'node:readline';
+
+function findProjectRoot(startDir) {
+    let dir = startDir || process.cwd();
+    while (dir !== path.dirname(dir)) {
+        // Check for tauri.conf.json in src-tauri
+        const tauriConfPath = path.join(dir, 'src-tauri', 'tauri.conf.json');
+        if (fs.existsSync(tauriConfPath)) {
+            return dir;
+        }
+        // Check for package.json as fallback
+        const packageJsonPath = path.join(dir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            // Verify it's a Tauri project
+            if (fs.existsSync(path.join(dir, 'src-tauri'))) {
+                return dir;
+            }
+        }
+        dir = path.dirname(dir);
+    }
+    throw new Error('Could not find Tauri project root. Make sure you are in a Tauri project directory.');
+}
+function readTauriConfig(projectRoot) {
+    const configPath = path.join(projectRoot, 'src-tauri', 'tauri.conf.json');
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`tauri.conf.json not found at ${configPath}`);
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse tauri.conf.json: ${error instanceof Error ? error.message : error}`);
+    }
+}
+function readBundleConfig$1(windowsDir) {
+    const configPath = path.join(windowsDir, 'bundle.config.json');
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`bundle.config.json not found. Run 'tauri-windows-bundle init' first.`);
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse bundle.config.json: ${error instanceof Error ? error.message : error}`);
+    }
+}
+function getWindowsDir(projectRoot) {
+    return path.join(projectRoot, 'src-tauri', 'gen', 'windows');
+}
+function toFourPartVersion(version) {
+    const parts = version.split('.');
+    while (parts.length < 4)
+        parts.push('0');
+    return parts.slice(0, 4).join('.');
+}
+
+const MSIX_ASSETS = [
+    { name: 'StoreLogo.png', size: 50 },
+    { name: 'Square44x44Logo.png', size: 44 },
+    { name: 'Square150x150Logo.png', size: 150 },
+    { name: 'Wide310x150Logo.png', width: 310, height: 150 },
+    { name: 'LargeTile.png', size: 310 },
+];
+const DEFAULT_MIN_WINDOWS_VERSION = '10.0.17763.0';
+const DEFAULT_CAPABILITIES = ['internetClient'];
+
+function generateBundleConfig(windowsDir, _tauriConfig) {
+    const config = {
+        publisher: 'CN=YourCompany',
+        publisherDisplayName: 'Your Company Name',
+        capabilities: DEFAULT_CAPABILITIES,
+        extensions: {
+            shareTarget: false,
+            fileAssociations: [],
+            protocolHandlers: [],
+        },
+        signing: {
+            pfx: null,
+            pfxPassword: null,
+        },
+    };
+    const configPath = path.join(windowsDir, 'bundle.config.json');
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+function generateGitignore(windowsDir) {
+    const gitignorePath = path.join(windowsDir, '.gitignore');
+    const content = `# Generated files
+# Keep bundle.config.json and templates in git
+`;
+    fs.writeFileSync(gitignorePath, content);
+}
+
+async function generateAssets(windowsDir) {
+    const assetsDir = path.join(windowsDir, 'Assets');
+    fs.mkdirSync(assetsDir, { recursive: true });
+    for (const asset of MSIX_ASSETS) {
+        const width = asset.width || asset.size || 50;
+        const height = asset.height || asset.size || 50;
+        const assetPath = path.join(assetsDir, asset.name);
+        // Generate a simple placeholder PNG
+        const pngData = createPlaceholderPng(width, height);
+        fs.writeFileSync(assetPath, pngData);
+    }
+    console.log('  Generated placeholder assets - replace with real icons before publishing');
+}
+function createPlaceholderPng(width, height) {
+    // Create a minimal valid PNG file (solid gray square)
+    // PNG signature
+    const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+    // IHDR chunk
+    const ihdrData = Buffer.alloc(13);
+    ihdrData.writeUInt32BE(width, 0);
+    ihdrData.writeUInt32BE(height, 4);
+    ihdrData.writeUInt8(8, 8); // bit depth
+    ihdrData.writeUInt8(2, 9); // color type (RGB)
+    ihdrData.writeUInt8(0, 10); // compression
+    ihdrData.writeUInt8(0, 11); // filter
+    ihdrData.writeUInt8(0, 12); // interlace
+    const ihdrChunk = createChunk('IHDR', ihdrData);
+    // IDAT chunk - raw image data (gray pixels)
+    const rawData = [];
+    for (let y = 0; y < height; y++) {
+        rawData.push(0); // filter byte
+        for (let x = 0; x < width; x++) {
+            rawData.push(128, 128, 128); // gray RGB
+        }
+    }
+    // Simple deflate compression (store block)
+    const uncompressed = Buffer.from(rawData);
+    const compressed = deflateStore(uncompressed);
+    const idatChunk = createChunk('IDAT', compressed);
+    // IEND chunk
+    const iendChunk = createChunk('IEND', Buffer.alloc(0));
+    return Buffer.concat([signature, ihdrChunk, idatChunk, iendChunk]);
+}
+function createChunk(type, data) {
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(data.length, 0);
+    const typeBuffer = Buffer.from(type, 'ascii');
+    const crcData = Buffer.concat([typeBuffer, data]);
+    const crc = crc32(crcData);
+    const crcBuffer = Buffer.alloc(4);
+    crcBuffer.writeUInt32BE(crc >>> 0, 0);
+    return Buffer.concat([length, typeBuffer, data, crcBuffer]);
+}
+function deflateStore(data) {
+    // Zlib header + store blocks
+    const result = [0x78, 0x01]; // zlib header
+    let remaining = data.length;
+    let offset = 0;
+    while (remaining > 0) {
+        const blockSize = Math.min(remaining, 65535);
+        const isLast = remaining <= 65535;
+        result.push(isLast ? 0x01 : 0x00); // BFINAL + BTYPE=00
+        result.push(blockSize & 0xff);
+        result.push((blockSize >> 8) & 0xff);
+        result.push(~blockSize & 0xff);
+        result.push((~blockSize >> 8) & 0xff);
+        for (let i = 0; i < blockSize; i++) {
+            result.push(data[offset + i]);
+        }
+        offset += blockSize;
+        remaining -= blockSize;
+    }
+    // Adler-32 checksum
+    const adler = adler32(data);
+    result.push((adler >> 24) & 0xff);
+    result.push((adler >> 16) & 0xff);
+    result.push((adler >> 8) & 0xff);
+    result.push(adler & 0xff);
+    return Buffer.from(result);
+}
+function crc32(data) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = crc & 1 ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1;
+        }
+    }
+    return crc ^ 0xffffffff;
+}
+function adler32(data) {
+    let a = 1;
+    let b = 0;
+    for (let i = 0; i < data.length; i++) {
+        a = (a + data[i]) % 65521;
+        b = (b + a) % 65521;
+    }
+    return (b << 16) | a;
+}
+
+function replaceTemplateVariables(template, variables) {
+    let result = template;
+    for (const [key, value] of Object.entries(variables)) {
+        const placeholder = `{{${key}}}`;
+        result = result.replaceAll(placeholder, value);
+    }
+    return result;
+}
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+function findPackageRoot(startDir) {
+    let dir = startDir;
+    while (dir !== path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    throw new Error('Could not find package root');
+}
+const PACKAGE_ROOT = findPackageRoot(__dirname$1);
+const TEMPLATES_DIR = path.join(PACKAGE_ROOT, 'templates');
+const EXTENSIONS_DIR = path.join(TEMPLATES_DIR, 'extensions');
+function loadTemplate(templatePath) {
+    return fs.readFileSync(templatePath, 'utf-8');
+}
+function getManifestTemplate() {
+    return loadTemplate(path.join(TEMPLATES_DIR, 'AppxManifest.xml.template'));
+}
+function getExtensionTemplate(name) {
+    return loadTemplate(path.join(EXTENSIONS_DIR, `${name}.xml`));
+}
+function generateManifestTemplate(windowsDir) {
+    const templatePath = path.join(windowsDir, 'AppxManifest.xml.template');
+    const template = getManifestTemplate();
+    fs.writeFileSync(templatePath, template);
+}
+function generateManifest(config, arch, minVersion) {
+    const variables = {
+        PACKAGE_NAME: config.identifier.replace(/\./g, ''),
+        PUBLISHER: config.publisher,
+        VERSION: config.version,
+        ARCH: arch,
+        DISPLAY_NAME: config.displayName,
+        PUBLISHER_DISPLAY_NAME: config.publisherDisplayName,
+        MIN_VERSION: minVersion,
+        EXECUTABLE: `${config.displayName.replace(/\s+/g, '')}.exe`,
+        DESCRIPTION: config.description || config.displayName,
+        EXTENSIONS: generateExtensions(config),
+        CAPABILITIES: generateCapabilities(config.capabilities || []),
+    };
+    return replaceTemplateVariables(getManifestTemplate(), variables);
+}
+function generateExtensions(config) {
+    const extensions = [];
+    if (config.extensions?.shareTarget) {
+        const template = getExtensionTemplate('share-target');
+        extensions.push(template.trimEnd());
+    }
+    if (config.extensions?.fileAssociations) {
+        const template = getExtensionTemplate('file-association');
+        for (const assoc of config.extensions.fileAssociations) {
+            const fileTypes = assoc.extensions
+                .map((ext) => `          <uap:FileType>${ext}</uap:FileType>`)
+                .join('\n');
+            const result = replaceTemplateVariables(template, {
+                NAME: assoc.name,
+                FILE_TYPES: fileTypes,
+            });
+            extensions.push(result.trimEnd());
+        }
+    }
+    if (config.extensions?.protocolHandlers) {
+        const template = getExtensionTemplate('protocol');
+        for (const handler of config.extensions.protocolHandlers) {
+            const result = replaceTemplateVariables(template, {
+                NAME: handler.name,
+                DISPLAY_NAME: handler.displayName || handler.name,
+            });
+            extensions.push(result.trimEnd());
+        }
+    }
+    if (config.extensions?.startupTask?.enabled) {
+        const template = getExtensionTemplate('startup-task');
+        const taskId = config.extensions.startupTask.taskId || 'StartupTask';
+        const result = replaceTemplateVariables(template, {
+            TASK_ID: taskId,
+            DISPLAY_NAME: config.displayName,
+        });
+        extensions.push(result.trimEnd());
+    }
+    if (config.extensions?.contextMenus) {
+        const template = getExtensionTemplate('context-menu');
+        for (const menu of config.extensions.contextMenus) {
+            const fileTypes = menu.fileTypes
+                .map((ft) => `            <desktop:FileType>${ft}</desktop:FileType>`)
+                .join('\n');
+            const result = replaceTemplateVariables(template, {
+                NAME: menu.name,
+                FILE_TYPES: fileTypes,
+            });
+            extensions.push(result.trimEnd());
+        }
+    }
+    if (config.extensions?.backgroundTasks) {
+        const template = getExtensionTemplate('background-task');
+        for (const task of config.extensions.backgroundTasks) {
+            const triggerType = task.type === 'timer'
+                ? 'TimeTrigger'
+                : task.type === 'systemEvent'
+                    ? 'SystemTrigger'
+                    : 'PushNotificationTrigger';
+            const result = replaceTemplateVariables(template, {
+                ENTRY_POINT: task.name,
+                TRIGGER_TYPE: triggerType,
+            });
+            extensions.push(result.trimEnd());
+        }
+    }
+    if (config.extensions?.appExecutionAliases) {
+        const template = getExtensionTemplate('app-execution-alias');
+        const executable = `${config.displayName.replace(/\s+/g, '')}.exe`;
+        for (const alias of config.extensions.appExecutionAliases) {
+            const result = replaceTemplateVariables(template, {
+                ALIAS: alias.alias.endsWith('.exe') ? alias.alias : `${alias.alias}.exe`,
+                EXECUTABLE: executable,
+            });
+            extensions.push(result.trimEnd());
+        }
+    }
+    if (config.extensions?.appServices) {
+        const template = getExtensionTemplate('app-service');
+        for (const service of config.extensions.appServices) {
+            const result = replaceTemplateVariables(template, {
+                NAME: service.name,
+            });
+            extensions.push(result.trimEnd());
+        }
+    }
+    if (config.extensions?.toastActivation) {
+        const template = getExtensionTemplate('toast-activation');
+        // Generate a CLSID from the identifier
+        const clsid = generateClsid(config.identifier + '.toast');
+        const result = replaceTemplateVariables(template, {
+            CLSID: clsid,
+        });
+        extensions.push(result.trimEnd());
+    }
+    if (config.extensions?.autoplayHandlers) {
+        for (const handler of config.extensions.autoplayHandlers) {
+            if (handler.contentEvent) {
+                const template = getExtensionTemplate('autoplay');
+                const result = replaceTemplateVariables(template, {
+                    VERB: handler.verb,
+                    ACTION_DISPLAY_NAME: handler.actionDisplayName,
+                    CONTENT_EVENT: handler.contentEvent,
+                });
+                extensions.push(result.trimEnd());
+            }
+            if (handler.deviceEvent) {
+                const template = getExtensionTemplate('autoplay-device');
+                const result = replaceTemplateVariables(template, {
+                    VERB: handler.verb,
+                    ACTION_DISPLAY_NAME: handler.actionDisplayName,
+                    DEVICE_EVENT: handler.deviceEvent,
+                });
+                extensions.push(result.trimEnd());
+            }
+        }
+    }
+    if (config.extensions?.printTaskSettings) {
+        const template = getExtensionTemplate('print-task-settings');
+        extensions.push(template.trimEnd());
+    }
+    if (config.extensions?.thumbnailHandlers) {
+        const template = getExtensionTemplate('thumbnail-handler');
+        for (const handler of config.extensions.thumbnailHandlers) {
+            const fileTypes = handler.fileTypes
+                .map((ext) => `          <uap:FileType>${ext}</uap:FileType>`)
+                .join('\n');
+            const result = replaceTemplateVariables(template, {
+                NAME: `thumbnail-${handler.clsid.replace(/[{}]/g, '').slice(0, 8)}`,
+                FILE_TYPES: fileTypes,
+                CLSID: handler.clsid,
+            });
+            extensions.push(result.trimEnd());
+        }
+    }
+    if (config.extensions?.previewHandlers) {
+        const template = getExtensionTemplate('preview-handler');
+        for (const handler of config.extensions.previewHandlers) {
+            const fileTypes = handler.fileTypes
+                .map((ext) => `          <uap:FileType>${ext}</uap:FileType>`)
+                .join('\n');
+            const result = replaceTemplateVariables(template, {
+                NAME: `preview-${handler.clsid.replace(/[{}]/g, '').slice(0, 8)}`,
+                FILE_TYPES: fileTypes,
+                CLSID: handler.clsid,
+            });
+            extensions.push(result.trimEnd());
+        }
+    }
+    return extensions.length > 0 ? extensions.join('\n\n') : '';
+}
+function generateCapabilities(capabilities) {
+    return capabilities.map((cap) => `    <Capability Name="${cap}" />`).join('\n');
+}
+function generateClsid(seed) {
+    // Generate a deterministic GUID-like string from the seed
+    let hash = 0;
+    for (let i = 0; i < seed.length; i++) {
+        const char = seed.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+    const hex = Math.abs(hash).toString(16).padStart(8, '0');
+    const hex2 = Math.abs(hash * 31)
+        .toString(16)
+        .padStart(8, '0');
+    const hex3 = Math.abs(hash * 37)
+        .toString(16)
+        .padStart(8, '0');
+    const hex4 = Math.abs(hash * 41)
+        .toString(16)
+        .padStart(12, '0');
+    return `{${hex.slice(0, 8)}-${hex2.slice(0, 4)}-${hex2.slice(4, 8)}-${hex3.slice(0, 4)}-${hex4.slice(0, 12)}}`.toUpperCase();
+}
+
+async function init(options) {
+    console.log('Initializing Windows bundle configuration...\n');
+    const projectRoot = findProjectRoot(options.path);
+    readTauriConfig(projectRoot);
+    const windowsDir = getWindowsDir(projectRoot);
+    // Create directories
+    fs.mkdirSync(path.join(windowsDir, 'Assets'), { recursive: true });
+    fs.mkdirSync(path.join(windowsDir, 'extensions'), { recursive: true });
+    // Generate bundle.config.json
+    generateBundleConfig(windowsDir);
+    console.log('  Created bundle.config.json');
+    // Generate AppxManifest.xml template
+    generateManifestTemplate(windowsDir);
+    console.log('  Created AppxManifest.xml.template');
+    // Generate placeholder assets
+    await generateAssets(windowsDir);
+    // Generate .gitignore
+    generateGitignore(windowsDir);
+    // Update package.json with build script
+    updatePackageJson(projectRoot);
+    console.log('  Added tauri:windows:build script to package.json');
+    console.log('\n Windows bundle configuration created!');
+    console.log(`\nNext steps:`);
+    console.log(`  1. Edit src-tauri/gen/windows/bundle.config.json`);
+    console.log(`     - Set your publisher CN (from your code signing certificate)`);
+    console.log(`     - Set your publisher display name`);
+    console.log(`  2. Replace placeholder icons in src-tauri/gen/windows/Assets/`);
+    console.log(`  3. Run: pnpm tauri:windows:build`);
+}
+function updatePackageJson(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        console.log('  Warning: package.json not found, skipping script update');
+        return;
+    }
+    try {
+        const content = fs.readFileSync(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        if (!pkg.scripts) {
+            pkg.scripts = {};
+        }
+        if (!pkg.scripts['tauri:windows:build']) {
+            pkg.scripts['tauri:windows:build'] = 'tauri-windows-bundle build';
+            fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+        }
+    }
+    catch (error) {
+        console.log(`  Warning: Could not update package.json: ${error instanceof Error ? error.message : error}`);
+    }
+}
+
+function prepareAppxContent(projectRoot, arch, config, tauriConfig, minVersion) {
+    const target = arch === 'x64' ? 'x86_64-pc-windows-msvc' : 'aarch64-pc-windows-msvc';
+    const buildDir = path.join(projectRoot, 'target', target, 'release');
+    const appxDir = path.join(projectRoot, 'target', 'appx', arch);
+    // Create directories
+    fs.mkdirSync(path.join(appxDir, 'Assets'), { recursive: true });
+    // Copy exe
+    const exeName = `${config.displayName.replace(/\s+/g, '')}.exe`;
+    const srcExe = path.join(buildDir, exeName);
+    if (!fs.existsSync(srcExe)) {
+        throw new Error(`Executable not found: ${srcExe}`);
+    }
+    fs.copyFileSync(srcExe, path.join(appxDir, exeName));
+    // Generate AppxManifest.xml
+    const manifest = generateManifest(config, arch, minVersion);
+    fs.writeFileSync(path.join(appxDir, 'AppxManifest.xml'), manifest);
+    // Copy MSIX Assets
+    const windowsAssetsDir = path.join(projectRoot, 'src-tauri', 'gen', 'windows', 'Assets');
+    if (fs.existsSync(windowsAssetsDir)) {
+        fs.cpSync(windowsAssetsDir, path.join(appxDir, 'Assets'), {
+            recursive: true,
+        });
+    }
+    // Copy bundled resources from tauri.conf.json
+    copyBundledResources(projectRoot, appxDir, tauriConfig);
+    return appxDir;
+}
+function copyBundledResources(projectRoot, appxDir, tauriConfig) {
+    const resources = tauriConfig.bundle?.resources;
+    if (!resources || resources.length === 0)
+        return;
+    const srcDir = path.join(projectRoot, 'src-tauri');
+    for (const resource of resources) {
+        if (typeof resource === 'string') {
+            // Glob pattern like "assets/*" or specific file
+            const files = glob.sync(resource, { cwd: srcDir });
+            for (const file of files) {
+                const src = path.join(srcDir, file);
+                const dest = path.join(appxDir, file);
+                fs.mkdirSync(path.dirname(dest), { recursive: true });
+                if (fs.statSync(src).isDirectory()) {
+                    fs.cpSync(src, dest, { recursive: true });
+                }
+                else {
+                    fs.copyFileSync(src, dest);
+                }
+            }
+        }
+        else if (typeof resource === 'object' && resource.src && resource.target) {
+            const src = path.join(srcDir, resource.src);
+            const dest = path.join(appxDir, resource.target);
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            if (fs.statSync(src).isDirectory()) {
+                fs.cpSync(src, dest, { recursive: true });
+            }
+            else {
+                fs.copyFileSync(src, dest);
+            }
+        }
+    }
+}
+
+const execPromise = promisify(exec);
+async function execAsync(command, options) {
+    const result = await execPromise(command, { ...options, encoding: 'utf8' });
+    return { stdout: result.stdout, stderr: result.stderr };
+}
+async function isMsixbundleCliInstalled() {
+    try {
+        await execAsync('msixbundle-cli --version');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getMsixbundleCliVersion() {
+    try {
+        const result = await execAsync('msixbundle-cli --version');
+        // Output format: "msixbundle-cli 1.0.0" or just "1.0.0"
+        const match = result.stdout.trim().match(/(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isVersionSufficient(version, minVersion) {
+    const parse = (v) => v.split('.').map((n) => parseInt(n, 10));
+    const [major, minor, patch] = parse(version);
+    const [minMajor, minMinor, minPatch] = parse(minVersion);
+    if (major > minMajor)
+        return true;
+    if (major < minMajor)
+        return false;
+    if (minor > minMinor)
+        return true;
+    if (minor < minMinor)
+        return false;
+    return patch >= minPatch;
+}
+const MIN_MSIXBUNDLE_CLI_VERSION = '1.0.0';
+async function promptInstall(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${message} [y/N] `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y');
+        });
+    });
+}
+
+async function build(options) {
+    console.log('Building MSIX package...\n');
+    // Check if msixbundle-cli is installed
+    if (!(await isMsixbundleCliInstalled())) {
+        const shouldInstall = await promptInstall('msixbundle-cli is required but not installed.\n' + 'Install it now? (requires Rust/Cargo)');
+        if (shouldInstall) {
+            console.log('Installing msixbundle-cli...');
+            try {
+                await execAsync('cargo install msixbundle-cli');
+                console.log('  msixbundle-cli installed\n');
+            }
+            catch (error) {
+                console.error('Failed to install msixbundle-cli:', error);
+                console.log('\nInstall manually: cargo install msixbundle-cli');
+                console.log('Or from: https://github.com/Choochmeque/msixbundle-rs');
+                process.exit(1);
+            }
+        }
+        else {
+            console.log('\nInstall manually: cargo install msixbundle-cli');
+            console.log('Or from: https://github.com/Choochmeque/msixbundle-rs');
+            process.exit(1);
+        }
+    }
+    // Check msixbundle-cli version
+    const version = await getMsixbundleCliVersion();
+    if (!version) {
+        console.error('Could not determine msixbundle-cli version');
+        process.exit(1);
+    }
+    if (!isVersionSufficient(version, MIN_MSIXBUNDLE_CLI_VERSION)) {
+        console.error(`msixbundle-cli version ${version} is too old. Minimum required: ${MIN_MSIXBUNDLE_CLI_VERSION}`);
+        console.log('Update with: cargo install msixbundle-cli --force');
+        process.exit(1);
+    }
+    const projectRoot = findProjectRoot();
+    const windowsDir = getWindowsDir(projectRoot);
+    // Read configs
+    const tauriConfig = readTauriConfig(projectRoot);
+    const bundleConfig = readBundleConfig$1(windowsDir);
+    // Merge config
+    const config = {
+        displayName: tauriConfig.productName || 'App',
+        version: toFourPartVersion(tauriConfig.version || '1.0.0'),
+        description: tauriConfig.bundle?.shortDescription || '',
+        identifier: tauriConfig.identifier || 'com.example.app',
+        ...bundleConfig,
+    };
+    // Architectures from CLI flag
+    const architectures = options.arch?.split(',') || ['x64'];
+    const minVersion = options.minWindows || DEFAULT_MIN_WINDOWS_VERSION;
+    const appxDirs = [];
+    for (const arch of architectures) {
+        console.log(`Building for ${arch}...`);
+        // Build Tauri app
+        const target = arch === 'x64' ? 'x86_64-pc-windows-msvc' : 'aarch64-pc-windows-msvc';
+        const releaseFlag = options.release ? '--release' : '';
+        try {
+            console.log(`  Running: cargo tauri build --target ${target} ${releaseFlag}`);
+            await execAsync(`cargo tauri build --target ${target} ${releaseFlag}`.trim(), {
+                cwd: projectRoot,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to build for ${arch}:`, error);
+            process.exit(1);
+        }
+        // Prepare AppxContent directory
+        console.log(`  Preparing AppxContent for ${arch}...`);
+        const appxDir = prepareAppxContent(projectRoot, arch, config, tauriConfig, minVersion);
+        appxDirs.push({ arch, dir: appxDir });
+        console.log(`  AppxContent ready: ${appxDir}`);
+    }
+    // Call msixbundle-cli
+    console.log('\nCreating MSIX package...');
+    const outDir = path.join(projectRoot, 'target', 'msix');
+    const args = [
+        '--out-dir',
+        outDir,
+        ...appxDirs.flatMap(({ arch, dir }) => [`--dir-${arch}`, dir]),
+    ];
+    // Signing
+    if (bundleConfig.signing?.pfx) {
+        args.push('--pfx', bundleConfig.signing.pfx);
+        const password = bundleConfig.signing.pfxPassword || process.env.MSIX_PFX_PASSWORD;
+        if (password) {
+            args.push('--pfx-password', password);
+        }
+    }
+    else if (tauriConfig.bundle?.windows?.certificateThumbprint) {
+        args.push('--thumbprint', tauriConfig.bundle.windows.certificateThumbprint);
+    }
+    try {
+        console.log(`  Running: msixbundle-cli ${args.join(' ')}`);
+        const result = await execAsync(`msixbundle-cli ${args.join(' ')}`);
+        if (result.stdout)
+            console.log(result.stdout);
+    }
+    catch (error) {
+        console.error('Failed to create MSIX:', error);
+        process.exit(1);
+    }
+    console.log('\n MSIX bundle created!');
+    console.log(`Output: ${outDir}`);
+}
+
+function readBundleConfig(windowsDir) {
+    const configPath = path.join(windowsDir, 'bundle.config.json');
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`bundle.config.json not found. Run 'tauri-windows-bundle init' first.`);
+    }
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+}
+function writeBundleConfig(windowsDir, config) {
+    const configPath = path.join(windowsDir, 'bundle.config.json');
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function extensionList(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nConfigured extensions:\n');
+    // Share Target
+    const shareTarget = config.extensions?.shareTarget ?? false;
+    console.log(`  Share Target: ${shareTarget ? 'enabled' : 'disabled'}`);
+    // File Associations
+    const fileAssociations = config.extensions?.fileAssociations ?? [];
+    if (fileAssociations.length > 0) {
+        console.log('\n  File Associations:');
+        for (const assoc of fileAssociations) {
+            console.log(`    - ${assoc.name}: ${assoc.extensions.join(', ')}`);
+        }
+    }
+    else {
+        console.log('\n  File Associations: none');
+    }
+    // Protocol Handlers
+    const protocolHandlers = config.extensions?.protocolHandlers ?? [];
+    if (protocolHandlers.length > 0) {
+        console.log('\n  Protocol Handlers:');
+        for (const handler of protocolHandlers) {
+            console.log(`    - ${handler.name}:// (${handler.displayName || handler.name})`);
+        }
+    }
+    else {
+        console.log('\n  Protocol Handlers: none');
+    }
+    // Startup Task
+    const startupTask = config.extensions?.startupTask;
+    console.log(`\n  Startup Task: ${startupTask?.enabled ? 'enabled' : 'disabled'}`);
+    // Context Menus
+    const contextMenus = config.extensions?.contextMenus ?? [];
+    if (contextMenus.length > 0) {
+        console.log('\n  Context Menus:');
+        for (const menu of contextMenus) {
+            console.log(`    - ${menu.name}: ${menu.fileTypes.join(', ')}`);
+        }
+    }
+    else {
+        console.log('\n  Context Menus: none');
+    }
+    // Background Tasks
+    const backgroundTasks = config.extensions?.backgroundTasks ?? [];
+    if (backgroundTasks.length > 0) {
+        console.log('\n  Background Tasks:');
+        for (const task of backgroundTasks) {
+            console.log(`    - ${task.name} (${task.type})`);
+        }
+    }
+    else {
+        console.log('\n  Background Tasks: none');
+    }
+    // App Execution Aliases
+    const aliases = config.extensions?.appExecutionAliases ?? [];
+    if (aliases.length > 0) {
+        console.log('\n  App Execution Aliases:');
+        for (const alias of aliases) {
+            console.log(`    - ${alias.alias}`);
+        }
+    }
+    else {
+        console.log('\n  App Execution Aliases: none');
+    }
+    // App Services
+    const appServices = config.extensions?.appServices ?? [];
+    if (appServices.length > 0) {
+        console.log('\n  App Services:');
+        for (const service of appServices) {
+            console.log(`    - ${service.name}`);
+        }
+    }
+    else {
+        console.log('\n  App Services: none');
+    }
+    // Toast Activation
+    const toastActivation = config.extensions?.toastActivation;
+    console.log(`\n  Toast Activation: ${toastActivation ? 'enabled' : 'disabled'}`);
+    // Autoplay Handlers
+    const autoplayHandlers = config.extensions?.autoplayHandlers ?? [];
+    if (autoplayHandlers.length > 0) {
+        console.log('\n  Autoplay Handlers:');
+        for (const handler of autoplayHandlers) {
+            console.log(`    - ${handler.verb}: ${handler.actionDisplayName}`);
+        }
+    }
+    else {
+        console.log('\n  Autoplay Handlers: none');
+    }
+    // Print Task Settings
+    const printTaskSettings = config.extensions?.printTaskSettings;
+    console.log(`\n  Print Task Settings: ${printTaskSettings ? 'enabled' : 'disabled'}`);
+    // Thumbnail Handlers
+    const thumbnailHandlers = config.extensions?.thumbnailHandlers ?? [];
+    if (thumbnailHandlers.length > 0) {
+        console.log('\n  Thumbnail Handlers:');
+        for (const handler of thumbnailHandlers) {
+            console.log(`    - ${handler.fileTypes.join(', ')}`);
+        }
+    }
+    else {
+        console.log('\n  Thumbnail Handlers: none');
+    }
+    // Preview Handlers
+    const previewHandlers = config.extensions?.previewHandlers ?? [];
+    if (previewHandlers.length > 0) {
+        console.log('\n  Preview Handlers:');
+        for (const handler of previewHandlers) {
+            console.log(`    - ${handler.fileTypes.join(', ')}`);
+        }
+    }
+    else {
+        console.log('\n  Preview Handlers: none');
+    }
+    console.log('');
+}
+async function extensionAddFileAssociation(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd File Association\n');
+    const name = await prompt('Association name (e.g., myfiles): ');
+    if (!name) {
+        console.log('Cancelled.');
+        return;
+    }
+    const extensionsInput = await prompt('File extensions (comma-separated, e.g., .myf,.myx): ');
+    if (!extensionsInput) {
+        console.log('Cancelled.');
+        return;
+    }
+    const extensions = extensionsInput.split(',').map((ext) => {
+        ext = ext.trim();
+        return ext.startsWith('.') ? ext : `.${ext}`;
+    });
+    const description = await prompt('Description (optional): ');
+    const fileAssociation = {
+        name,
+        extensions,
+    };
+    if (description) {
+        fileAssociation.description = description;
+    }
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.fileAssociations) {
+        config.extensions.fileAssociations = [];
+    }
+    // Check for duplicate
+    const existing = config.extensions.fileAssociations.find((a) => a.name === name);
+    if (existing) {
+        console.log(`\nFile association '${name}' already exists. Updating...`);
+        Object.assign(existing, fileAssociation);
+    }
+    else {
+        config.extensions.fileAssociations.push(fileAssociation);
+    }
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nFile association '${name}' added successfully.`);
+}
+async function extensionAddProtocol(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd Protocol Handler\n');
+    const name = await prompt('Protocol name (e.g., myapp): ');
+    if (!name) {
+        console.log('Cancelled.');
+        return;
+    }
+    const displayName = await prompt(`Display name (default: ${name}): `);
+    const protocolHandler = {
+        name,
+    };
+    if (displayName) {
+        protocolHandler.displayName = displayName;
+    }
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.protocolHandlers) {
+        config.extensions.protocolHandlers = [];
+    }
+    // Check for duplicate
+    const existing = config.extensions.protocolHandlers.find((p) => p.name === name);
+    if (existing) {
+        console.log(`\nProtocol handler '${name}' already exists. Updating...`);
+        Object.assign(existing, protocolHandler);
+    }
+    else {
+        config.extensions.protocolHandlers.push(protocolHandler);
+    }
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nProtocol handler '${name}://' added successfully.`);
+}
+async function extensionEnableShareTarget(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    config.extensions.shareTarget = true;
+    writeBundleConfig(windowsDir, config);
+    console.log('\nShare Target enabled.');
+}
+async function extensionDisableShareTarget(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    config.extensions.shareTarget = false;
+    writeBundleConfig(windowsDir, config);
+    console.log('\nShare Target disabled.');
+}
+async function extensionEnableStartupTask(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    config.extensions.startupTask = { enabled: true };
+    writeBundleConfig(windowsDir, config);
+    console.log('\nStartup Task enabled. App will run on Windows login.');
+}
+async function extensionDisableStartupTask(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    config.extensions.startupTask = { enabled: false };
+    writeBundleConfig(windowsDir, config);
+    console.log('\nStartup Task disabled.');
+}
+async function extensionAddContextMenu(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd Context Menu\n');
+    const name = await prompt('Menu item name (e.g., open-with-myapp): ');
+    if (!name) {
+        console.log('Cancelled.');
+        return;
+    }
+    const fileTypesInput = await prompt('File types (comma-separated, e.g., *, .txt, .doc): ');
+    if (!fileTypesInput) {
+        console.log('Cancelled.');
+        return;
+    }
+    const fileTypes = fileTypesInput.split(',').map((t) => t.trim());
+    const displayName = await prompt('Display name (shown in menu): ');
+    const contextMenu = {
+        name,
+        fileTypes,
+    };
+    if (displayName) {
+        contextMenu.displayName = displayName;
+    }
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.contextMenus) {
+        config.extensions.contextMenus = [];
+    }
+    const existing = config.extensions.contextMenus.find((m) => m.name === name);
+    if (existing) {
+        console.log(`\nContext menu '${name}' already exists. Updating...`);
+        Object.assign(existing, contextMenu);
+    }
+    else {
+        config.extensions.contextMenus.push(contextMenu);
+    }
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nContext menu '${name}' added successfully.`);
+}
+async function extensionAddBackgroundTask(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd Background Task\n');
+    const name = await prompt('Task name (e.g., sync-task): ');
+    if (!name) {
+        console.log('Cancelled.');
+        return;
+    }
+    console.log('Task types:');
+    console.log('  1. timer - Runs periodically');
+    console.log('  2. systemEvent - Runs on system events');
+    console.log('  3. pushNotification - Runs on push notification');
+    const typeInput = await prompt('Task type (1/2/3): ');
+    const typeMap = {
+        '1': 'timer',
+        '2': 'systemEvent',
+        '3': 'pushNotification',
+        timer: 'timer',
+        systemevent: 'systemEvent',
+        pushnotification: 'pushNotification',
+    };
+    const taskType = typeMap[typeInput.toLowerCase()];
+    if (!taskType) {
+        console.log('Invalid task type. Cancelled.');
+        return;
+    }
+    const backgroundTask = {
+        name,
+        type: taskType,
+    };
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.backgroundTasks) {
+        config.extensions.backgroundTasks = [];
+    }
+    const existing = config.extensions.backgroundTasks.find((t) => t.name === name);
+    if (existing) {
+        console.log(`\nBackground task '${name}' already exists. Updating...`);
+        Object.assign(existing, backgroundTask);
+    }
+    else {
+        config.extensions.backgroundTasks.push(backgroundTask);
+    }
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nBackground task '${name}' (${taskType}) added successfully.`);
+}
+async function extensionAddAppExecutionAlias(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd App Execution Alias\n');
+    const alias = await prompt('Alias name (e.g., myapp): ');
+    if (!alias) {
+        console.log('Cancelled.');
+        return;
+    }
+    const appAlias = { alias };
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.appExecutionAliases) {
+        config.extensions.appExecutionAliases = [];
+    }
+    const existing = config.extensions.appExecutionAliases.find((a) => a.alias === alias);
+    if (existing) {
+        console.log(`\nAlias '${alias}' already exists.`);
+        return;
+    }
+    config.extensions.appExecutionAliases.push(appAlias);
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nApp execution alias '${alias}' added. You can run your app from command line.`);
+}
+async function extensionAddAppService(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd App Service\n');
+    const name = await prompt('Service name (e.g., com.myapp.service): ');
+    if (!name) {
+        console.log('Cancelled.');
+        return;
+    }
+    const appService = { name };
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.appServices) {
+        config.extensions.appServices = [];
+    }
+    const existing = config.extensions.appServices.find((s) => s.name === name);
+    if (existing) {
+        console.log(`\nApp service '${name}' already exists.`);
+        return;
+    }
+    config.extensions.appServices.push(appService);
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nApp service '${name}' added. Other apps can now call into your app.`);
+}
+async function extensionEnableToastActivation(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    config.extensions.toastActivation = { activationType: 'foreground' };
+    writeBundleConfig(windowsDir, config);
+    console.log('\nToast Activation enabled. Your app will handle toast notification clicks.');
+}
+async function extensionDisableToastActivation(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (config.extensions) {
+        delete config.extensions.toastActivation;
+    }
+    writeBundleConfig(windowsDir, config);
+    console.log('\nToast Activation disabled.');
+}
+async function extensionAddAutoplay(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd Autoplay Handler\n');
+    const verb = await prompt('Verb (e.g., open, play): ');
+    if (!verb) {
+        console.log('Cancelled.');
+        return;
+    }
+    const actionDisplayName = await prompt('Action display name (e.g., Open with MyApp): ');
+    if (!actionDisplayName) {
+        console.log('Cancelled.');
+        return;
+    }
+    console.log('Event type:');
+    console.log('  1. Content event (e.g., PlayMusicFilesOnArrival)');
+    console.log('  2. Device event (e.g., WPD\\ImageSource)');
+    const eventType = await prompt('Event type (1/2): ');
+    const handler = { verb, actionDisplayName };
+    if (eventType === '1') {
+        const contentEvent = await prompt('Content event (e.g., PlayMusicFilesOnArrival): ');
+        if (!contentEvent) {
+            console.log('Cancelled.');
+            return;
+        }
+        handler.contentEvent = contentEvent;
+    }
+    else if (eventType === '2') {
+        const deviceEvent = await prompt('Device event (e.g., WPD\\\\ImageSource): ');
+        if (!deviceEvent) {
+            console.log('Cancelled.');
+            return;
+        }
+        handler.deviceEvent = deviceEvent;
+    }
+    else {
+        console.log('Invalid event type. Cancelled.');
+        return;
+    }
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.autoplayHandlers) {
+        config.extensions.autoplayHandlers = [];
+    }
+    config.extensions.autoplayHandlers.push(handler);
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nAutoplay handler '${verb}' added.`);
+}
+async function extensionEnablePrintTaskSettings(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    config.extensions.printTaskSettings = { displayName: 'Print Settings' };
+    writeBundleConfig(windowsDir, config);
+    console.log('\nPrint Task Settings enabled.');
+}
+async function extensionDisablePrintTaskSettings(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (config.extensions) {
+        delete config.extensions.printTaskSettings;
+    }
+    writeBundleConfig(windowsDir, config);
+    console.log('\nPrint Task Settings disabled.');
+}
+async function extensionAddThumbnailHandler(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd Thumbnail Handler\n');
+    const clsid = await prompt('CLSID (e.g., {12345678-1234-1234-1234-123456789012}): ');
+    if (!clsid) {
+        console.log('Cancelled.');
+        return;
+    }
+    const fileTypesInput = await prompt('File types (comma-separated, e.g., .myf,.myx): ');
+    if (!fileTypesInput) {
+        console.log('Cancelled.');
+        return;
+    }
+    const fileTypes = fileTypesInput.split(',').map((t) => t.trim());
+    const handler = { clsid, fileTypes };
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.thumbnailHandlers) {
+        config.extensions.thumbnailHandlers = [];
+    }
+    config.extensions.thumbnailHandlers.push(handler);
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nThumbnail handler added for ${fileTypes.join(', ')}.`);
+}
+async function extensionAddPreviewHandler(options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    console.log('\nAdd Preview Handler\n');
+    const clsid = await prompt('CLSID (e.g., {12345678-1234-1234-1234-123456789012}): ');
+    if (!clsid) {
+        console.log('Cancelled.');
+        return;
+    }
+    const fileTypesInput = await prompt('File types (comma-separated, e.g., .myf,.myx): ');
+    if (!fileTypesInput) {
+        console.log('Cancelled.');
+        return;
+    }
+    const fileTypes = fileTypesInput.split(',').map((t) => t.trim());
+    const handler = { clsid, fileTypes };
+    if (!config.extensions) {
+        config.extensions = {};
+    }
+    if (!config.extensions.previewHandlers) {
+        config.extensions.previewHandlers = [];
+    }
+    config.extensions.previewHandlers.push(handler);
+    writeBundleConfig(windowsDir, config);
+    console.log(`\nPreview handler added for ${fileTypes.join(', ')}.`);
+}
+async function extensionRemove(type, name, options) {
+    const projectRoot = findProjectRoot(options.path);
+    const windowsDir = getWindowsDir(projectRoot);
+    const config = readBundleConfig(windowsDir);
+    if (!config.extensions) {
+        console.log('\nNo extensions configured.');
+        return;
+    }
+    switch (type) {
+        case 'file-association': {
+            if (!config.extensions.fileAssociations) {
+                console.log('\nNo file associations configured.');
+                return;
+            }
+            const index = config.extensions.fileAssociations.findIndex((a) => a.name === name);
+            if (index === -1) {
+                console.log(`\nFile association '${name}' not found.`);
+                return;
+            }
+            config.extensions.fileAssociations.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nFile association '${name}' removed.`);
+            break;
+        }
+        case 'protocol': {
+            if (!config.extensions.protocolHandlers) {
+                console.log('\nNo protocol handlers configured.');
+                return;
+            }
+            const index = config.extensions.protocolHandlers.findIndex((p) => p.name === name);
+            if (index === -1) {
+                console.log(`\nProtocol handler '${name}' not found.`);
+                return;
+            }
+            config.extensions.protocolHandlers.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nProtocol handler '${name}' removed.`);
+            break;
+        }
+        case 'context-menu': {
+            if (!config.extensions.contextMenus) {
+                console.log('\nNo context menus configured.');
+                return;
+            }
+            const index = config.extensions.contextMenus.findIndex((m) => m.name === name);
+            if (index === -1) {
+                console.log(`\nContext menu '${name}' not found.`);
+                return;
+            }
+            config.extensions.contextMenus.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nContext menu '${name}' removed.`);
+            break;
+        }
+        case 'background-task': {
+            if (!config.extensions.backgroundTasks) {
+                console.log('\nNo background tasks configured.');
+                return;
+            }
+            const index = config.extensions.backgroundTasks.findIndex((t) => t.name === name);
+            if (index === -1) {
+                console.log(`\nBackground task '${name}' not found.`);
+                return;
+            }
+            config.extensions.backgroundTasks.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nBackground task '${name}' removed.`);
+            break;
+        }
+        case 'app-execution-alias': {
+            if (!config.extensions.appExecutionAliases) {
+                console.log('\nNo app execution aliases configured.');
+                return;
+            }
+            const index = config.extensions.appExecutionAliases.findIndex((a) => a.alias === name);
+            if (index === -1) {
+                console.log(`\nApp execution alias '${name}' not found.`);
+                return;
+            }
+            config.extensions.appExecutionAliases.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nApp execution alias '${name}' removed.`);
+            break;
+        }
+        case 'app-service': {
+            if (!config.extensions.appServices) {
+                console.log('\nNo app services configured.');
+                return;
+            }
+            const index = config.extensions.appServices.findIndex((s) => s.name === name);
+            if (index === -1) {
+                console.log(`\nApp service '${name}' not found.`);
+                return;
+            }
+            config.extensions.appServices.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nApp service '${name}' removed.`);
+            break;
+        }
+        case 'autoplay': {
+            if (!config.extensions.autoplayHandlers) {
+                console.log('\nNo autoplay handlers configured.');
+                return;
+            }
+            const index = config.extensions.autoplayHandlers.findIndex((h) => h.verb === name);
+            if (index === -1) {
+                console.log(`\nAutoplay handler '${name}' not found.`);
+                return;
+            }
+            config.extensions.autoplayHandlers.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nAutoplay handler '${name}' removed.`);
+            break;
+        }
+        case 'thumbnail-handler': {
+            if (!config.extensions.thumbnailHandlers) {
+                console.log('\nNo thumbnail handlers configured.');
+                return;
+            }
+            const index = config.extensions.thumbnailHandlers.findIndex((h) => h.clsid === name);
+            if (index === -1) {
+                console.log(`\nThumbnail handler '${name}' not found.`);
+                return;
+            }
+            config.extensions.thumbnailHandlers.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nThumbnail handler removed.`);
+            break;
+        }
+        case 'preview-handler': {
+            if (!config.extensions.previewHandlers) {
+                console.log('\nNo preview handlers configured.');
+                return;
+            }
+            const index = config.extensions.previewHandlers.findIndex((h) => h.clsid === name);
+            if (index === -1) {
+                console.log(`\nPreview handler '${name}' not found.`);
+                return;
+            }
+            config.extensions.previewHandlers.splice(index, 1);
+            writeBundleConfig(windowsDir, config);
+            console.log(`\nPreview handler removed.`);
+            break;
+        }
+        default:
+            console.log(`\nUnknown extension type: ${type}`);
+            console.log('Valid types: file-association, protocol, context-menu, background-task, ' +
+                'app-execution-alias, app-service, autoplay, thumbnail-handler, preview-handler');
+    }
+}
+
+const program = new Command();
+program
+    .name('tauri-windows-bundle')
+    .description('MSIX packaging tool for Tauri apps')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Initialize Windows bundle configuration')
+    .option('-p, --path <path>', 'Path to Tauri project')
+    .action(async (options) => {
+    try {
+        await init(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command('build')
+    .description('Build MSIX package')
+    .option('--arch <architectures>', 'Architectures to build (comma-separated: x64,arm64)', 'x64')
+    .option('--release', 'Build in release mode')
+    .option('--min-windows <version>', 'Minimum Windows version', '10.0.17763.0')
+    .action(async (options) => {
+    try {
+        await build(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Extension commands
+const extension = program.command('extension').description('Manage Windows app extensions');
+extension
+    .command('list')
+    .description('List configured extensions')
+    .option('-p, --path <path>', 'Path to Tauri project')
+    .action(async (options) => {
+    try {
+        await extensionList(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+extension
+    .command('add')
+    .description('Add an extension')
+    .argument('<type>', 'Extension type')
+    .option('-p, --path <path>', 'Path to Tauri project')
+    .action(async (type, options) => {
+    try {
+        switch (type) {
+            case 'file-association':
+                await extensionAddFileAssociation(options);
+                break;
+            case 'protocol':
+                await extensionAddProtocol(options);
+                break;
+            case 'share-target':
+                await extensionEnableShareTarget(options);
+                break;
+            case 'startup-task':
+                await extensionEnableStartupTask(options);
+                break;
+            case 'context-menu':
+                await extensionAddContextMenu(options);
+                break;
+            case 'background-task':
+                await extensionAddBackgroundTask(options);
+                break;
+            case 'app-execution-alias':
+                await extensionAddAppExecutionAlias(options);
+                break;
+            case 'app-service':
+                await extensionAddAppService(options);
+                break;
+            case 'toast-activation':
+                await extensionEnableToastActivation(options);
+                break;
+            case 'autoplay':
+                await extensionAddAutoplay(options);
+                break;
+            case 'print-task-settings':
+                await extensionEnablePrintTaskSettings(options);
+                break;
+            case 'thumbnail-handler':
+                await extensionAddThumbnailHandler(options);
+                break;
+            case 'preview-handler':
+                await extensionAddPreviewHandler(options);
+                break;
+            default:
+                console.error(`Unknown extension type: ${type}`);
+                console.log('Valid types: file-association, protocol, share-target, startup-task, context-menu, ' +
+                    'background-task, app-execution-alias, app-service, toast-activation, autoplay, ' +
+                    'print-task-settings, thumbnail-handler, preview-handler');
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+extension
+    .command('remove')
+    .description('Remove an extension')
+    .argument('<type>', 'Extension type')
+    .argument('[name]', 'Extension name/identifier (required for most types)')
+    .option('-p, --path <path>', 'Path to Tauri project')
+    .action(async (type, name, options) => {
+    try {
+        // Toggle extensions (no name required)
+        if (type === 'share-target') {
+            await extensionDisableShareTarget(options);
+        }
+        else if (type === 'startup-task') {
+            await extensionDisableStartupTask(options);
+        }
+        else if (type === 'toast-activation') {
+            await extensionDisableToastActivation(options);
+        }
+        else if (type === 'print-task-settings') {
+            await extensionDisablePrintTaskSettings(options);
+        }
+        else {
+            // Extensions that require a name
+            if (!name) {
+                console.error('Name is required for this extension type');
+                process.exit(1);
+            }
+            await extensionRemove(type, name, options);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program.parse();