globox 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+## v3.0.0 (Upcoming)
+
+### New Features
+
+- `globox scan` — discover all Node.js projects on your machine and show which package manager each uses
+- Per-project `node_modules` disk usage breakdown
+- System-wide view of your entire Node.js footprint across all projects
+- Dashboard view for scan results with sortable project list
+
+---
+
+## v2.0.0 (Upcoming)
+
+### New Features
+
+- `globox rm` — interactive multi-select to uninstall global packages from any manager
+- Dashboard delete button per row with confirmation dialog
+- `globox update` — interactive update of outdated global packages
+- `globox sync` — migrate global packages from one manager to another
+
+---
+
+## v1.0.0 (2026.2.17)
+
+### Features
+
+- List all globally installed packages across npm, pnpm, and yarn with a single command
+- Auto-detect which package managers are installed (skip missing ones gracefully)
+- Group packages by manager (npm first, then pnpm, then yarn)
+- `--size` / `-s` — show disk size of each package
+- `--sort <field>` — sort by `name` (default) or `size`
+- `--outdated` / `-o` — check which packages have newer versions available
+- `--doctor` — detect duplicate packages installed across multiple managers
+- `--export <path>` / `-e` — export package list to JSON or CSV
+- `--dashboard` / `-d` — launch an interactive web dashboard in the browser
+- `--json` / `-j` — output raw JSON for scripting and piping
+- `--manager <names>` / `-m` — filter by specific package managers
+
+### Dashboard
+
+- Search and filter packages in real-time
+- Filter by package manager with toggle buttons
+- Sortable columns (Package, Size, Manager) with click-to-sort
+- "Check for updates" button with lazy fetch (no upfront latency)
+- Pre-load outdated data with `globox -d -o`
+- Stats cards showing total packages, total disk size, and per-manager counts
+- Dark theme, responsive design
+- Auto-opens in browser, shuts down cleanly on Ctrl+C

package/README.md

@@ -0,0 +1,136 @@
+# globox
+
+One command to list all globally installed npm, pnpm, and yarn packages — with an optional dashboard.
+
+```diff
+- npm list -g --depth=0
+- pnpm list -g
+- yarn global list
++ globox
+```
+
+## Quick Start
+
+```bash
+# Install
+npm install -g globox
+
+# List all global packages
+globox
+
+# Open the interactive dashboard
+globox -d
+```
+
+That's it. globox auto-detects which package managers you have and aggregates everything into one view.
+
+## Why
+
+Managing global packages across multiple package managers is painful:
+
+- **Three different commands** — `npm list -g`, `pnpm list -g`, `yarn global list` each with different output formats
+- **No unified view** — impossible to see everything at a glance without running commands one by one
+- **Hidden disk usage** — global packages silently eat gigabytes with no easy way to see which ones are the biggest
+- **Duplicates go unnoticed** — the same package installed in both npm and pnpm wastes space and causes confusion
+- **Outdated packages pile up** — no single command checks for updates across all managers
+- **No export or backup** — switching machines means manually remembering what you had installed
+
+globox fixes all of this with one command that works across npm, pnpm, and yarn.
+
+## Usage
+
+```bash
+# List everything (grouped by manager)
+globox
+
+# Show disk sizes
+globox -s
+
+# Sort by size (biggest first)
+globox --sort size
+
+# Filter to one manager
+globox -m pnpm
+
+# Check for outdated packages
+globox --outdated
+
+# Find duplicates across managers
+globox --doctor
+
+# Export to file
+globox --export globals.json
+globox --export globals.csv
+
+# JSON output (great for piping)
+globox --json
+
+# Open the web dashboard
+globox -d
+
+# Dashboard with pre-loaded outdated info
+globox -d -o
+```
+
+## Dashboard
+
+Run `globox -d` to launch a temporary web dashboard:
+
+- Search and filter packages in real-time
+- Click column headers to sort by Package, Size, or Manager
+- Filter by package manager with toggle buttons
+- "Check for updates" button to see outdated packages
+- Stats at a glance — total packages, total disk size, per-manager counts
+- Auto-opens in your browser, shuts down on Ctrl+C
+
+## How It Works
+
+1. **Detect** — globox checks which package managers are installed (npm, pnpm, yarn)
+2. **Scan** — runs each manager's list command in parallel and parses the output
+3. **Display** — aggregates results into a formatted table, JSON, or interactive dashboard
+
+Managers that aren't installed are silently skipped. Yarn Berry (v2+) is handled gracefully since `yarn global` was removed.
+
+## Commands
+
+```bash
+globox                           # List all global packages
+globox -d, --dashboard           # Open interactive web dashboard
+globox -m, --manager <names>     # Filter by manager (comma-separated: npm,pnpm,yarn)
+globox -s, --size                # Show disk size of each package
+globox --sort <field>            # Sort by: name (default) or size
+globox -o, --outdated            # Show outdated packages with latest versions
+globox --doctor                  # Detect duplicates across managers
+globox -e, --export <path>       # Export to JSON or CSV file
+globox -j, --json                # Output as JSON
+globox --no-color                # Disable colored output
+globox -v, --version             # Print version
+globox -h, --help                # Show help
+```
+
+Flags can be combined:
+
+```bash
+globox -s -m npm                 # npm packages with sizes
+globox --sort size -m pnpm       # pnpm packages sorted by size
+globox -d -o                     # dashboard with pre-loaded outdated info
+globox --json --sort size        # JSON output sorted by size
+```
+
+## Supported Package Managers
+
+| Manager | Detection | Global List | Notes |
+| --- | --- | --- | --- |
+| **npm** | `npm --version` | `npm list -g --json` | Full support |
+| **pnpm** | `pnpm --version` | `pnpm list -g --json` | Full support |
+| **yarn** | `yarn --version` | `yarn global list` | v1 (Classic) only — Yarn Berry removed `yarn global` |
+
+Managers that aren't installed are silently skipped.
+
+## Requirements
+
+- Node.js >= 18
+
+## License
+
+MIT

package/bin/globox.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import {
+  detectManagers,
+  listAllPackages,
+  printTable,
+  printOutdatedTable,
+  checkOutdated,
+  findDuplicates,
+  printDuplicates,
+  exportPackages,
+  enrichWithSizes,
+  startDashboard,
+} from "../src/index.js";
+
+const program = new Command();
+
+program
+  .name("globox")
+  .description(
+    "One command to list all globally installed npm, pnpm, and yarn packages."
+  )
+  .version("1.0.0", "-v, --version")
+  .option("-d, --dashboard", "Open an interactive dashboard in the browser")
+  .option(
+    "-m, --manager <managers>",
+    "Filter by package manager (comma-separated: npm,pnpm,yarn)"
+  )
+  .option("-j, --json", "Output as JSON")
+  .option("-o, --outdated", "Show only outdated packages")
+  .option("--doctor", "Detect duplicate packages across managers")
+  .option("-e, --export <path>", "Export package list to a JSON or CSV file")
+  .option("-s, --size", "Show disk size of each package")
+  .option("--sort <field>", "Sort by: name (default) or size", "name")
+  .option("--no-color", "Disable colored output")
+  .showHelpAfterError(true)
+  .allowExcessArguments(false);
+
+program.on("command:*", ([cmd]) => {
+  console.error(chalk.red(`\n  Unknown command: ${cmd}\n`));
+  console.error(`  Run ${chalk.bold("globox --help")} to see available options.\n`);
+  process.exit(1);
+});
+
+program.parse();
+
+const opts = program.opts();
+
+async function fetchOutdated(pkgs) {
+  const spinner = ora("Checking for updates...").start();
+  const enriched = await checkOutdated(pkgs, {
+    onProgress: (done, total) => {
+      spinner.text = `Checking for updates... (${done}/${total})`;
+    },
+  });
+  spinner.succeed("Version check complete");
+  return enriched;
+}
+
+async function main() {
+  const filter = opts.manager
+    ? opts.manager.split(",").map((m) => m.trim().toLowerCase())
+    : null;
+
+  // Detect managers
+  const detectSpinner = ora("Detecting package managers...").start();
+  const managers = await detectManagers(filter);
+
+  if (managers.length === 0) {
+    detectSpinner.fail("No package managers found.");
+    if (filter) {
+      console.log(
+        chalk.yellow(
+          `\n  None of the specified managers (${filter.join(", ")}) are installed.\n`
+        )
+      );
+    }
+    process.exit(1);
+  }
+
+  detectSpinner.succeed(
+    `Found ${managers.map((m) => `${chalk.bold(m.name)} v${m.version}`).join(", ")}`
+  );
+
+  // List packages
+  const listSpinner = ora("Scanning global packages...").start();
+  const packages = await listAllPackages(managers);
+  listSpinner.succeed(`Found ${chalk.bold(packages.length)} global packages`);
+
+  if (packages.length === 0) {
+    console.log(
+      chalk.yellow("\n  No globally installed packages found.\n")
+    );
+    process.exit(0);
+  }
+
+  // Enrich with disk sizes if requested, dashboard, or sorting by size
+  const needsSize = opts.size || opts.dashboard || opts.sort === "size";
+  let pkgs = packages;
+  if (needsSize) {
+    const sizeSpinner = ora("Calculating package sizes...").start();
+    pkgs = await enrichWithSizes(packages, {
+      onProgress: (done, total) => {
+        sizeSpinner.text = `Calculating package sizes... (${done}/${total})`;
+      },
+    });
+    sizeSpinner.succeed("Size calculation complete");
+  }
+
+  // Apply sort
+  if (opts.sort === "size") {
+    pkgs = [...pkgs].sort((a, b) => (b.size || 0) - (a.size || 0));
+  }
+
+  // JSON output
+  if (opts.json) {
+    console.log(JSON.stringify(pkgs, null, 2));
+    return;
+  }
+
+  // Dashboard
+  if (opts.dashboard) {
+    const dashPkgs = opts.outdated ? await fetchOutdated(pkgs) : pkgs;
+    await startDashboard(dashPkgs, managers, { outdated: opts.outdated });
+    return;
+  }
+
+  // Doctor mode
+  if (opts.doctor) {
+    const duplicates = findDuplicates(pkgs);
+    printDuplicates(duplicates);
+    return;
+  }
+
+  // Outdated mode
+  if (opts.outdated) {
+    printOutdatedTable(await fetchOutdated(pkgs));
+    return;
+  }
+
+  // Export
+  if (opts.export) {
+    await exportPackages(pkgs, opts.export);
+    return;
+  }
+
+  // Default: print table
+  printTable(pkgs, { showSize: opts.size || opts.sort === "size" });
+}
+
+main().catch((err) => {
+  console.error(chalk.red(`\n  Error: ${err.message}\n`));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "globox",
+  "version": "1.0.1",
+  "description": "One command to list all globally installed npm, pnpm, and yarn packages — with an optional dashboard.",
+  "type": "module",
+  "bin": {
+    "globox": "./bin/globox.js"
+  },
+  "main": "./src/index.js",
+  "scripts": {
+    "start": "node bin/globox.js",
+    "test": "node bin/globox.js"
+  },
+  "keywords": [
+    "cli",
+    "npm",
+    "pnpm",
+    "yarn",
+    "global",
+    "packages",
+    "dashboard",
+    "list",
+    "package-manager"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0",
+    "execa": "^9.5.2",
+    "open": "^10.1.0",
+    "ora": "^8.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/constants.js

@@ -0,0 +1 @@
+export const MANAGER_ORDER = { npm: 0, pnpm: 1, yarn: 2 };

package/src/dashboard/server.js

@@ -0,0 +1,87 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import open from "open";
+import chalk from "chalk";
+import { checkOutdated } from "../outdated.js";
+import { MANAGER_ORDER } from "../constants.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Start a temporary dashboard server and open it in the browser.
+ * Returns a cleanup function to shut down the server.
+ */
+export async function startDashboard(packages, managers, { outdated = false } = {}) {
+  const templatePath = join(__dirname, "template.html");
+  let html = await readFile(templatePath, "utf-8");
+
+  const payload = JSON.stringify({
+    packages,
+    managers: managers.map((m) => ({ name: m.name, version: m.version })),
+    managerOrder: MANAGER_ORDER,
+    generatedAt: new Date().toISOString(),
+    outdatedPreloaded: outdated,
+  });
+
+  html = html.replace("__GLOBOX_DATA__", payload);
+
+  let outdatedCache = null;
+
+  const server = createServer(async (req, res) => {
+    if (req.url === "/api/outdated") {
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+      });
+
+      try {
+        if (!outdatedCache) {
+          outdatedCache = await checkOutdated(packages);
+        }
+        res.end(JSON.stringify(outdatedCache));
+      } catch (err) {
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(html);
+  });
+
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", async () => {
+      const { port } = server.address();
+      const url = `http://127.0.0.1:${port}`;
+
+      console.log(
+        chalk.cyan(
+          `\n  Dashboard running at ${chalk.bold.underline(url)}`
+        )
+      );
+      console.log(chalk.gray("  Press Ctrl+C to stop and clean up\n"));
+
+      await open(url);
+
+      const cleanup = () => {
+        server.close();
+        console.log(chalk.gray("\n  Dashboard stopped.\n"));
+      };
+
+      process.on("SIGINT", () => {
+        cleanup();
+        process.exit(0);
+      });
+
+      process.on("SIGTERM", () => {
+        cleanup();
+        process.exit(0);
+      });
+
+      resolve(cleanup);
+    });
+  });
+}