@tukuyomil032/broom 1.0.0

package/dist/commands/uninstall.js

@@ -0,0 +1,336 @@
+/**
+ * Uninstall command - Remove applications and their leftovers
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { readdir, stat, rm } from 'fs/promises';
+import { join } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { enhanceCommandHelp } from '../utils/help.js';
+import { paths } from '../utils/paths.js';
+import { exists, getSize, formatSize, isProtectedPath, expandPath } from '../utils/fs.js';
+import { printHeader, warning, error, info, createSpinner, succeedSpinner, failSpinner, printSummaryBlock, } from '../ui/output.js';
+import { selectApp, selectFiles, confirmAction } from '../ui/prompts.js';
+const execAsync = promisify(exec);
+/**
+ * Get bundle ID from app's Info.plist
+ */
+async function getBundleId(appPath) {
+    try {
+        const plistPath = join(appPath, 'Contents', 'Info.plist');
+        if (!exists(plistPath)) {
+            return null;
+        }
+        // Use plutil to convert plist to JSON
+        const { stdout } = await execAsync(`plutil -convert json -o - "${plistPath}"`);
+        const plist = JSON.parse(stdout);
+        return plist.CFBundleIdentifier || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Scan for installed applications
+ */
+async function scanApplications() {
+    const apps = [];
+    const appDirs = [paths.applications, paths.userApplications];
+    for (const appDir of appDirs) {
+        try {
+            if (!exists(appDir)) {
+                continue;
+            }
+            const entries = await readdir(appDir);
+            for (const entry of entries) {
+                if (!entry.endsWith('.app')) {
+                    continue;
+                }
+                const appPath = join(appDir, entry);
+                try {
+                    const stats = await stat(appPath);
+                    if (!stats.isDirectory()) {
+                        continue;
+                    }
+                    const size = await getSize(appPath);
+                    const bundleId = await getBundleId(appPath);
+                    const name = entry.replace('.app', '');
+                    apps.push({
+                        name,
+                        path: appPath,
+                        bundleId: bundleId || undefined,
+                        size,
+                    });
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+        }
+        catch {
+            // Skip if cannot access directory
+        }
+    }
+    // Sort by name
+    apps.sort((a, b) => a.name.localeCompare(b.name));
+    return apps;
+}
+/**
+ * Find app-related files
+ */
+async function findAppFiles(app) {
+    const items = [];
+    const searchTerms = [];
+    // Build search terms from app name and bundle ID
+    if (app.bundleId) {
+        searchTerms.push(app.bundleId);
+        // Also search for variations (e.g., com.company.app -> company.app)
+        const parts = app.bundleId.split('.');
+        if (parts.length >= 2) {
+            searchTerms.push(parts.slice(-2).join('.'));
+        }
+    }
+    // Add app name variations
+    searchTerms.push(app.name);
+    searchTerms.push(app.name.toLowerCase());
+    searchTerms.push(app.name.replace(/\s+/g, ''));
+    // Directories to search
+    const searchDirs = [
+        paths.userCache,
+        paths.applicationSupport,
+        paths.preferences,
+        paths.savedState,
+        paths.userLogs,
+        join(paths.applicationSupport, '..', 'Containers'),
+        join(paths.applicationSupport, '..', 'Group Containers'),
+    ];
+    for (const searchDir of searchDirs) {
+        try {
+            if (!exists(searchDir)) {
+                continue;
+            }
+            const entries = await readdir(searchDir);
+            for (const entry of entries) {
+                const entryLower = entry.toLowerCase();
+                // Check if entry matches any search term
+                const matches = searchTerms.some((term) => entryLower.includes(term.toLowerCase()));
+                if (!matches) {
+                    continue;
+                }
+                const entryPath = join(searchDir, entry);
+                try {
+                    const stats = await stat(entryPath);
+                    const size = await getSize(entryPath);
+                    items.push({
+                        path: entryPath,
+                        size,
+                        name: entry,
+                        isDirectory: stats.isDirectory(),
+                        modifiedAt: stats.mtime,
+                    });
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+        }
+        catch {
+            // Skip if cannot access directory
+        }
+    }
+    // Also check for launch agents/daemons
+    const launchDirs = [
+        join(expandPath('~'), 'Library', 'LaunchAgents'),
+        '/Library/LaunchAgents',
+        '/Library/LaunchDaemons',
+    ];
+    for (const launchDir of launchDirs) {
+        try {
+            if (!exists(launchDir)) {
+                continue;
+            }
+            const entries = await readdir(launchDir);
+            for (const entry of entries) {
+                if (!entry.endsWith('.plist')) {
+                    continue;
+                }
+                const entryLower = entry.toLowerCase();
+                const matches = searchTerms.some((term) => entryLower.includes(term.toLowerCase()));
+                if (!matches) {
+                    continue;
+                }
+                const entryPath = join(launchDir, entry);
+                try {
+                    const stats = await stat(entryPath);
+                    items.push({
+                        path: entryPath,
+                        size: stats.size,
+                        name: entry,
+                        isDirectory: false,
+                        modifiedAt: stats.mtime,
+                    });
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+        }
+        catch {
+            // Skip if cannot access directory
+        }
+    }
+    // Sort by size descending
+    items.sort((a, b) => b.size - a.size);
+    return items;
+}
+/**
+ * Remove app using Finder (moves to trash)
+ */
+async function removeAppToTrash(appPath) {
+    try {
+        const script = `tell application "Finder" to delete POSIX file "${appPath}"`;
+        await execAsync(`osascript -e '${script}'`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Execute uninstall command
+ */
+export async function uninstallCommand(options) {
+    const isDryRun = options.dryRun || false;
+    printHeader(isDryRun ? '🗑️ Uninstall Apps (Dry Run)' : '🗑️ Uninstall Apps');
+    // Scan for apps
+    const spinner = createSpinner('Scanning applications...');
+    const apps = await scanApplications();
+    succeedSpinner(spinner, `Found ${apps.length} applications`);
+    if (apps.length === 0) {
+        warning('No applications found');
+        return;
+    }
+    // Select app
+    console.log();
+    const selectedApp = await selectApp(apps);
+    if (!selectedApp) {
+        warning('No application selected');
+        return;
+    }
+    // Find related files
+    console.log();
+    const searchSpinner = createSpinner(`Searching for ${selectedApp.name} related files...`);
+    const relatedFiles = await findAppFiles(selectedApp);
+    succeedSpinner(searchSpinner, `Found ${relatedFiles.length} related files`);
+    // Show app info
+    console.log();
+    console.log(chalk.bold(`Application: ${selectedApp.name}`));
+    console.log(`  Path: ${chalk.dim(selectedApp.path)}`);
+    console.log(`  Size: ${chalk.yellow(formatSize(selectedApp.size))}`);
+    if (selectedApp.bundleId) {
+        console.log(`  Bundle ID: ${chalk.dim(selectedApp.bundleId)}`);
+    }
+    // Show related files
+    if (relatedFiles.length > 0) {
+        const totalRelatedSize = relatedFiles.reduce((sum, f) => sum + f.size, 0);
+        console.log();
+        console.log(chalk.bold(`Related Files (${formatSize(totalRelatedSize)}):`));
+        for (const file of relatedFiles.slice(0, 10)) {
+            console.log(`  ${file.isDirectory ? '📁' : '📄'} ${chalk.dim(file.path)} ${chalk.yellow(formatSize(file.size))}`);
+        }
+        if (relatedFiles.length > 10) {
+            console.log(chalk.dim(`  ... and ${relatedFiles.length - 10} more`));
+        }
+    }
+    // Confirm uninstall
+    console.log();
+    if (!options.yes) {
+        const confirmed = await confirmAction(`Uninstall ${selectedApp.name} and remove related files?`, false);
+        if (!confirmed) {
+            warning('Uninstall cancelled');
+            return;
+        }
+    }
+    // Select files to remove
+    let filesToRemove = relatedFiles;
+    if (!options.yes && relatedFiles.length > 0) {
+        console.log();
+        info('Select which related files to remove:');
+        filesToRemove = await selectFiles(relatedFiles);
+    }
+    // Execute uninstall
+    console.log();
+    const uninstallSpinner = createSpinner(isDryRun ? 'Simulating uninstall...' : 'Uninstalling...');
+    let appRemoved = false;
+    let filesRemoved = 0;
+    let freedSpace = 0;
+    const errors = [];
+    if (!isDryRun) {
+        // Remove app
+        appRemoved = await removeAppToTrash(selectedApp.path);
+        if (appRemoved) {
+            freedSpace += selectedApp.size;
+        }
+        else {
+            errors.push(`Failed to remove ${selectedApp.name}`);
+        }
+        // Remove related files
+        for (const file of filesToRemove) {
+            if (isProtectedPath(file.path)) {
+                errors.push(`Skipped protected path: ${file.path}`);
+                continue;
+            }
+            try {
+                await rm(file.path, { recursive: true, force: true });
+                filesRemoved++;
+                freedSpace += file.size;
+            }
+            catch (err) {
+                errors.push(`Failed to remove ${file.path}: ${err.message}`);
+            }
+        }
+    }
+    else {
+        // Dry run - just count
+        appRemoved = true;
+        freedSpace = selectedApp.size;
+        filesRemoved = filesToRemove.length;
+        freedSpace += filesToRemove.reduce((sum, f) => sum + f.size, 0);
+    }
+    if (errors.length === 0) {
+        succeedSpinner(uninstallSpinner, isDryRun ? 'Simulation complete' : 'Uninstall complete');
+    }
+    else {
+        failSpinner(uninstallSpinner, 'Uninstall completed with errors');
+    }
+    // Print summary
+    const summaryHeading = isDryRun ? 'Dry Run Complete' : 'Uninstall Complete';
+    const summaryDetails = [
+        `Application: ${appRemoved ? chalk.green('Removed') : chalk.red('Failed')}`,
+        `Related files removed: ${filesRemoved}`,
+        `Space freed: ${chalk.green(formatSize(freedSpace))}`,
+    ];
+    if (errors.length > 0) {
+        summaryDetails.push(`${chalk.red(`Errors: ${errors.length}`)}`);
+    }
+    printSummaryBlock(summaryHeading, summaryDetails);
+    if (errors.length > 0) {
+        console.log();
+        console.log(chalk.bold.red('Errors:'));
+        errors.forEach((err) => error(err));
+    }
+}
+/**
+ * Create uninstall command
+ */
+export function createUninstallCommand() {
+    const cmd = new Command('uninstall')
+        .description('Remove apps and their leftovers')
+        .option('-n, --dry-run', 'Preview only, no deletions')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (options) => {
+        await uninstallCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}

package/dist/commands/update.js

@@ -0,0 +1,182 @@
+/**
+ * update command - Self-update broom to the latest version
+ */
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import ora from 'ora';
+import { confirm } from '@inquirer/prompts';
+import { enhanceCommandHelp } from '../utils/help.js';
+const PACKAGE_NAME = 'broom-cli';
+/**
+ * Get current installed version
+ */
+function getCurrentVersion() {
+    try {
+        const packageJson = require('../../package.json');
+        return packageJson.version;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Get latest version from npm
+ */
+function getLatestVersion() {
+    try {
+        // Try npm
+        const result = execSync(`npm view ${PACKAGE_NAME} version 2>/dev/null`, {
+            encoding: 'utf-8',
+            timeout: 10000,
+        });
+        return result.trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compare semver versions
+ */
+function compareVersions(current, latest) {
+    const parseParts = (v) => v.split('.').map((n) => parseInt(n, 10) || 0);
+    const currentParts = parseParts(current);
+    const latestParts = parseParts(latest);
+    for (let i = 0; i < 3; i++) {
+        const c = currentParts[i] || 0;
+        const l = latestParts[i] || 0;
+        if (l > c) {
+            return 1; // newer
+        }
+        if (l < c) {
+            return -1; // older
+        }
+    }
+    return 0; // same
+}
+/**
+ * Check for updates
+ */
+async function checkForUpdates() {
+    const spinner = ora('Checking for updates...').start();
+    const current = getCurrentVersion();
+    const latest = getLatestVersion();
+    if (!latest) {
+        spinner.warn('Could not fetch latest version');
+        console.log(chalk.dim('\nMake sure you have internet connection.'));
+        return;
+    }
+    spinner.stop();
+    console.log(chalk.bold('\n📦 broom Version Info\n'));
+    console.log(`  Current version:  ${chalk.cyan(current)}`);
+    console.log(`  Latest version:   ${chalk.green(latest)}`);
+    const cmp = compareVersions(current, latest);
+    if (cmp > 0) {
+        console.log(chalk.yellow('\n  Update available!'));
+        console.log(chalk.dim(`  Run 'broom update' to update.\n`));
+    }
+    else if (cmp < 0) {
+        console.log(chalk.cyan('\n  You are running a newer version.\n'));
+    }
+    else {
+        console.log(chalk.green('\n  You are up to date!\n'));
+    }
+}
+/**
+ * Detect package manager
+ */
+function detectPackageManager() {
+    const managers = ['bun', 'pnpm', 'yarn', 'npm'];
+    for (const manager of managers) {
+        try {
+            execSync(`which ${manager}`, { stdio: 'pipe' });
+            return manager;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Perform update
+ */
+async function performUpdate(skipConfirm) {
+    const current = getCurrentVersion();
+    const spinner = ora('Checking for updates...').start();
+    const latest = getLatestVersion();
+    if (!latest) {
+        spinner.fail('Could not fetch latest version');
+        return;
+    }
+    const cmp = compareVersions(current, latest);
+    if (cmp <= 0) {
+        spinner.succeed(`Already up to date (v${current})`);
+        return;
+    }
+    spinner.info(`Update available: ${current} → ${latest}`);
+    if (!skipConfirm) {
+        const confirmed = await confirm({
+            message: `Update broom to v${latest}?`,
+            default: true,
+        });
+        if (!confirmed) {
+            console.log(chalk.yellow('Update cancelled'));
+            return;
+        }
+    }
+    const pm = detectPackageManager();
+    if (!pm) {
+        console.error(chalk.red('No package manager found'));
+        console.log(chalk.dim('Install npm, yarn, pnpm, or bun first.'));
+        return;
+    }
+    const updateSpinner = ora(`Updating broom using ${pm}...`).start();
+    try {
+        let cmd;
+        switch (pm) {
+            case 'npm':
+                cmd = `npm update -g ${PACKAGE_NAME}`;
+                break;
+            case 'yarn':
+                cmd = `yarn global upgrade ${PACKAGE_NAME}`;
+                break;
+            case 'pnpm':
+                cmd = `pnpm update -g ${PACKAGE_NAME}`;
+                break;
+            case 'bun':
+                cmd = `bun update -g ${PACKAGE_NAME}`;
+                break;
+        }
+        execSync(cmd, { stdio: 'pipe' });
+        updateSpinner.succeed(`Successfully updated to v${latest}`);
+        console.log(chalk.dim('\nChangelog: https://github.com/your-username/broom/releases'));
+    }
+    catch (error) {
+        updateSpinner.fail('Update failed');
+        if (error instanceof Error) {
+            console.error(chalk.red(error.message));
+        }
+        console.log(chalk.dim('\nTry running manually:'));
+        console.log(chalk.dim(`  npm install -g ${PACKAGE_NAME}@latest`));
+    }
+}
+/**
+ * Create update command
+ */
+export function createUpdateCommand() {
+    const cmd = new Command('update')
+        .description('Self-update broom to the latest version')
+        .option('-c, --check', 'Check for updates only (no install)')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (opts) => {
+        if (opts.check) {
+            await checkForUpdates();
+        }
+        else {
+            await performUpdate(opts.yes);
+        }
+    });
+    return enhanceCommandHelp(cmd);
+}