offline-npm-manager 1.0.5

package/README.md

@@ -0,0 +1,279 @@
+# 📦 Offline NPM Manager - CLI Tool
+
+A command-line tool for downloading npm packages when online and installing them offline later.
+
+---
+
+## Features
+
+**✅ Add Packages** - Download packages and dependencies for offline use
+
+**✅ Install Packages** - Install from local cache without internet
+
+**✅ List Packages** - View all cached packages
+
+**✅ Remove Packages** - Clean up cached packages
+
+**✅ Dependency Management** - Automatically cache package dependencies
+
+**✅ Smart Caching** - Detect already-cached packages
+
+**✅ Scoped Packages** - Full support for `@scope/package` naming
+
+**✅ Cross-Platform** - Works on Windows, macOS, and Linux
+
+**✅ Version Control** - Store and manage multiple versions
+
+**✅ Real-time Feedback** - Progress indicators and error messages
+
+---
+
+## Installation
+
+### Prerequisites
+
+- **Node.js** 16 or higher
+- **npm** 8 or higher
+
+### Install Globally
+
+```bash
+npm install -g offline-npm-manager
+```
+
+This installs the `offline-npm` command globally.
+
+### Offline Installation
+
+```bash
+npm install -g offline-npm-manager --offline
+```
+
+---
+
+## Usage
+
+### Add a Package
+
+Download and store a package locally (requires internet):
+
+```bash
+offline-npm add <package>
+```
+
+Examples:
+
+```bash
+offline-npm add axios
+offline-npm add react --deps
+offline-npm add react@17.0.2
+offline-npm add @babel/core
+```
+
+**Options:**
+
+- `-d, --deps` → Download all dependencies recursively
+- `-s, --storage <path>` → Custom storage directory
+
+---
+
+### Install a Package
+
+Install from local cache (works offline):
+
+```bash
+offline-npm install <package>
+```
+
+Examples:
+
+```bash
+offline-npm install axios --save
+offline-npm install lodash --save-dev
+offline-npm install react@17.0.2
+```
+
+**Options:**
+
+- `--save` → Add to dependencies
+- `--save-dev` → Add to devDependencies
+- `-s, --storage <path>` → Custom storage
+
+---
+
+### List Cached Packages
+
+```bash
+offline-npm list
+offline-npm ls
+```
+
+Example output:
+
+```
+📦  offline-npm list
+
+Storage: ~/.offline-npm-cache
+
+┌──────────┬─────────┬──────────┬───────────────────────┬─────────┐
+│ Package  │ Version │ Size     │ Downloaded            │ Status  │
+├──────────┼─────────┼──────────┼───────────────────────┼─────────┤
+│ lodash   │ 4.17.23 │ 307.5 KB │ 3/24/2026, 9:48 AM    │ ✔ ready │
+│ express  │ 5.2.1   │ 22.6 KB  │ 3/24/2026, 10:15 AM   │ ✔ ready │
+└──────────┴─────────┴──────────┴───────────────────────┴─────────┘
+```
+
+---
+
+### Remove a Package
+
+```bash
+offline-npm remove <package>
+```
+
+Example:
+
+```bash
+offline-npm remove lodash
+```
+
+---
+
+## Storage
+
+Default locations:
+
+- **Windows** → `%USERPROFILE%\.offline-npm-cache`
+- **macOS/Linux** → `~/.offline-npm-cache`
+
+Override storage:
+
+```bash
+offline-npm add react --storage /custom/path
+```
+
+---
+
+## Storage Structure
+
+```
+~/.offline-npm-cache/
+├── lodash/
+│   └── 4.17.23/
+│       ├── lodash-4.17.23.tgz
+│       └── meta.json
+├── express/
+│   └── 5.2.1/
+│       ├── express-5.2.1.tgz
+│       └── meta.json
+└── @babel/
+    └── core/
+        └── 7.20.5/
+            ├── core-7.20.5.tgz
+            └── meta.json
+```
+
+---
+
+## meta.json Example
+
+```json
+{
+  "name": "express",
+  "version": "5.2.1",
+  "size": 23150,
+  "downloadedAt": "2026-03-24T10:15:30Z",
+  "hasDeps": true
+}
+```
+
+---
+
+## Uninstall
+
+```bash
+npm uninstall -g offline-npm-manager
+```
+
+This removes the CLI.
+
+(Optional: manually delete cache if needed)
+
+```bash
+rm -rf ~/.offline-npm-cache
+```
+
+---
+
+## Example Workflow
+
+```bash
+# Step 1: Online
+offline-npm add express@4.18.2 --deps
+offline-npm add lodash
+offline-npm list
+
+# Step 2: Go Offline
+
+# Step 3: Install
+mkdir my-project && cd my-project
+npm init -y
+
+offline-npm install express@4.18.2 --save
+offline-npm install lodash --save
+```
+
+---
+
+## How It Works
+
+| Operation    | Description                        |
+| ------------ | ---------------------------------- |
+| Add Package  | Uses `npm pack` to download `.tgz` |
+| Install      | Installs from local `.tgz`         |
+| List         | Reads cached metadata              |
+| Remove       | Deletes cached files               |
+| Dependencies | Recursively cached with `--deps`   |
+
+---
+
+## Requirements
+
+- Node.js ≥ 16
+- npm ≥ 8
+
+---
+
+## Troubleshooting
+
+### npm not found
+
+```bash
+npm --version
+```
+
+Install Node.js or fix PATH.
+
+---
+
+### Package not found
+
+```bash
+offline-npm add lodash
+```
+
+Check spelling or internet connection.
+
+---
+
+### Missing dependencies
+
+```bash
+offline-npm add express --deps
+```
+
+---
+
+## License
+
+MIT

package/bin/offline-npm.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { program } = require("commander");
+const { addPackage } = require("../src/add.js");
+const { installPackage } = require("../src/install.js");
+const { listPackages } = require("../src/list.js");
+const { removePackage } = require("../src/remove.js");
+const { version } = require("../package.json");
+
+program
+  .name("offline-npm")
+  .description(
+    "📦 Download npm packages when online, install them offline later",
+  )
+  .version(version);
+
+program
+  .command("add <package>")
+  .description("Download a package and store it locally (requires internet)")
+  .option("-d, --deps", "Also download all dependencies recursively", false)
+  .option("-s, --storage <path>", "Custom storage directory")
+  .action(async (pkg, options) => {
+    await addPackage(pkg, options);
+  });
+
+program
+  .command("install <package>")
+  .description("Install a package from local offline storage")
+  .option("-s, --storage <path>", "Custom storage directory")
+  .option("--save", "Add to package.json dependencies", false)
+  .option("--save-dev", "Add to package.json devDependencies", false)
+  .action(async (pkg, options) => {
+    await installPackage(pkg, options);
+  });
+
+program
+  .command("list")
+  .alias("ls")
+  .description("List all locally stored packages")
+  .option("-s, --storage <path>", "Custom storage directory")
+  .action(async (options) => {
+    await listPackages(options);
+  });
+
+program
+  .command("remove <package>")
+  .alias("rm")
+  .description("Remove a package from local offline storage")
+  .option("-s, --storage <path>", "Custom storage directory")
+  .action(async (pkg, options) => {
+    await removePackage(pkg, options);
+  });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/dist/cli.cjs

@@ -0,0 +1,720 @@
+#!/usr/bin/env node
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/parser.js
+var require_parser = __commonJS({
+  "src/parser.js"(exports2, module2) {
+    "use strict";
+    function parsePackage(input) {
+      input = input.trim();
+      if (input.startsWith("@")) {
+        const secondAt = input.indexOf("@", 1);
+        if (secondAt === -1) {
+          return { name: input, version: "latest", raw: input };
+        }
+        return {
+          name: input.slice(0, secondAt),
+          version: input.slice(secondAt + 1),
+          raw: input
+        };
+      }
+      const atIndex = input.indexOf("@");
+      if (atIndex === -1) {
+        return { name: input, version: "latest", raw: input };
+      }
+      return {
+        name: input.slice(0, atIndex),
+        version: input.slice(atIndex + 1),
+        raw: input
+      };
+    }
+    function packageLabel(name, version2) {
+      return `${name}@${version2}`;
+    }
+    module2.exports = { parsePackage, packageLabel };
+  }
+});
+
+// src/storage.js
+var require_storage = __commonJS({
+  "src/storage.js"(exports2, module2) {
+    "use strict";
+    var path = require("path");
+    var os = require("os");
+    var fs = require("fs");
+    var DEFAULT_STORAGE = path.join(os.homedir(), ".offline-npm-cache");
+    function getStorageDir(customPath = null) {
+      const dir = customPath ? path.resolve(customPath) : DEFAULT_STORAGE;
+      ensureDir(dir);
+      return dir;
+    }
+    function getPackageDir(storageDir, name, version2) {
+      const dir = path.join(storageDir, name, version2);
+      ensureDir(dir);
+      return dir;
+    }
+    function ensureDir(dir) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+    function readMeta(pkgDir) {
+      const metaPath = path.join(pkgDir, "meta.json");
+      if (!fs.existsSync(metaPath))
+        return null;
+      return JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+    }
+    function writeMeta(pkgDir, meta) {
+      const metaPath = path.join(pkgDir, "meta.json");
+      fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
+    }
+    module2.exports = {
+      DEFAULT_STORAGE,
+      getStorageDir,
+      getPackageDir,
+      ensureDir,
+      readMeta,
+      writeMeta
+    };
+  }
+});
+
+// src/logger.js
+var require_logger = __commonJS({
+  "src/logger.js"(exports2, module2) {
+    "use strict";
+    var RESET = "\x1B[0m";
+    var BOLD = "\x1B[1m";
+    var DIM = "\x1B[2m";
+    var GREEN = "\x1B[32m";
+    var CYAN = "\x1B[36m";
+    var YELLOW = "\x1B[33m";
+    var RED = "\x1B[31m";
+    var BLUE = "\x1B[34m";
+    function info(msg) {
+      console.log(`${CYAN}\u2139${RESET}  ${msg}`);
+    }
+    function success(msg) {
+      console.log(`${GREEN}\u2714${RESET}  ${msg}`);
+    }
+    function warn(msg) {
+      console.log(`${YELLOW}\u26A0${RESET}  ${msg}`);
+    }
+    function error(msg) {
+      console.error(`${RED}\u2716${RESET}  ${msg}`);
+    }
+    function step(msg) {
+      console.log(`${BLUE}\u203A${RESET}  ${msg}`);
+    }
+    function dim(msg) {
+      console.log(`${DIM}   ${msg}${RESET}`);
+    }
+    function bold(msg) {
+      return `${BOLD}${msg}${RESET}`;
+    }
+    function header(msg) {
+      console.log(`
+${BOLD}${CYAN}${msg}${RESET}
+`);
+    }
+    function table(rows) {
+      if (!rows.length)
+        return;
+      const cols = Object.keys(rows[0]);
+      const widths = cols.map(
+        (c) => Math.max(c.length, ...rows.map((r) => String(r[c] ?? "").length))
+      );
+      const line = widths.map((w) => "\u2500".repeat(w + 2)).join("\u253C");
+      const header2 = cols.map((c, i) => ` ${BOLD}${c.padEnd(widths[i])}${RESET} `).join("\u2502");
+      console.log("\u250C" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u252C") + "\u2510");
+      console.log("\u2502" + header2 + "\u2502");
+      console.log("\u251C" + line + "\u2524");
+      rows.forEach((row) => {
+        const cells = cols.map((c, i) => ` ${String(row[c] ?? "").padEnd(widths[i])} `).join("\u2502");
+        console.log("\u2502" + cells + "\u2502");
+      });
+      console.log("\u2514" + widths.map((w) => "\u2500".repeat(w + 2)).join("\u2534") + "\u2518");
+    }
+    module2.exports = { info, success, warn, error, step, dim, bold, header, table };
+  }
+});
+
+// src/add.js
+var require_add = __commonJS({
+  "src/add.js"(exports2, module2) {
+    "use strict";
+    var { execSync, spawnSync } = require("child_process");
+    var fs = require("fs");
+    var path = require("path");
+    var { parsePackage, packageLabel } = require_parser();
+    var { getStorageDir, getPackageDir, writeMeta } = require_storage();
+    var log = require_logger();
+    function resolveVersion(name, version2) {
+      try {
+        const result = execSync(
+          `npm view ${packageLabel(name, version2)} version --json`,
+          { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+        ).trim();
+        return result.replace(/"/g, "");
+      } catch (err) {
+        throw new Error(
+          `Could not resolve version for ${packageLabel(name, version2)}. Are you online? Does this package exist?`
+        );
+      }
+    }
+    function getDependencies(name, version2) {
+      try {
+        const raw = execSync(
+          `npm view ${packageLabel(name, version2)} dependencies --json`,
+          { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+        ).trim();
+        if (!raw || raw === "undefined")
+          return {};
+        return JSON.parse(raw);
+      } catch {
+        return {};
+      }
+    }
+    function npmPack(pkgLabel, destDir) {
+      if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+      }
+      try {
+        const cmd = `npm pack ${pkgLabel} --pack-destination "${destDir}"`;
+        const output = execSync(cmd, { encoding: "utf-8" });
+        const lines = output.trim().split("\n").filter((l) => l.trim() && !l.includes("npm"));
+        const tgzName = lines.pop().trim();
+        if (!tgzName) {
+          throw new Error(`No output from npm pack for ${pkgLabel}`);
+        }
+        return path.join(destDir, tgzName);
+      } catch (err) {
+        log.error(`npm pack failed: ${err.message}`);
+        throw err;
+      }
+    }
+    async function downloadPackage(name, version2, storageDir, downloadDeps, visited = /* @__PURE__ */ new Set()) {
+      const label = packageLabel(name, version2);
+      if (visited.has(label))
+        return;
+      visited.add(label);
+      log.step(`Resolving ${log.bold(label)} ...`);
+      let resolvedVersion;
+      try {
+        resolvedVersion = resolveVersion(name, version2);
+      } catch (err) {
+        log.error(err.message);
+        process.exit(1);
+      }
+      const pkgDir = getPackageDir(storageDir, name, resolvedVersion);
+      const metaPath = path.join(pkgDir, "meta.json");
+      if (fs.existsSync(metaPath)) {
+        const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+        if (meta.tgz && fs.existsSync(path.join(pkgDir, meta.tgz))) {
+          log.info(
+            `Already cached: ${log.bold(packageLabel(name, resolvedVersion))}`
+          );
+          return;
+        }
+      }
+      log.step(`Downloading ${log.bold(packageLabel(name, resolvedVersion))} ...`);
+      let tgzPath;
+      try {
+        tgzPath = npmPack(packageLabel(name, resolvedVersion), pkgDir);
+      } catch (err) {
+        log.error(`Failed to download ${label}: ${err.message}`);
+        process.exit(1);
+      }
+      const tgzName = path.basename(tgzPath);
+      const stats = fs.statSync(tgzPath);
+      writeMeta(pkgDir, {
+        name,
+        version: resolvedVersion,
+        requestedVersion: version2,
+        tgz: tgzName,
+        size: stats.size,
+        downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        hasDeps: downloadDeps
+      });
+      log.success(
+        `Saved ${log.bold(packageLabel(name, resolvedVersion))} (${(stats.size / 1024).toFixed(1)} KB) \u2192 ${pkgDir}`
+      );
+      if (downloadDeps) {
+        const deps = getDependencies(name, resolvedVersion);
+        const depEntries = Object.entries(deps);
+        if (depEntries.length > 0) {
+          log.info(
+            `Found ${depEntries.length} dependenc${depEntries.length === 1 ? "y" : "ies"} for ${packageLabel(name, resolvedVersion)}`
+          );
+          for (const [depName, depRange] of depEntries) {
+            await downloadPackage(
+              depName,
+              depRange,
+              storageDir,
+              downloadDeps,
+              visited
+            );
+          }
+        }
+      }
+    }
+    async function addPackage2(pkgInput, options) {
+      const { name, version: version2 } = parsePackage(pkgInput);
+      const storageDir = getStorageDir(options.storage);
+      log.header(`\u{1F4E6}  offline-npm add`);
+      log.info(`Storage directory: ${storageDir}`);
+      if (options.deps) {
+        log.info(`Dependency download: ${log.bold("enabled")}`);
+      }
+      console.log("");
+      await downloadPackage(name, version2, storageDir, options.deps);
+      console.log("");
+      log.success(
+        `Done! Run ${log.bold(`offline-npm install ${pkgInput}`)} anytime \u2014 even offline.`
+      );
+    }
+    module2.exports = { addPackage: addPackage2 };
+  }
+});
+
+// src/install.js
+var require_install = __commonJS({
+  "src/install.js"(exports2, module2) {
+    "use strict";
+    var { spawnSync } = require("child_process");
+    var fs = require("fs");
+    var path = require("path");
+    var { parsePackage, packageLabel } = require_parser();
+    var { getStorageDir, readMeta } = require_storage();
+    var log = require_logger();
+    function findCachedVersions(storageDir, name) {
+      const pkgPath = path.join(storageDir, ...name.split("/"));
+      if (!fs.existsSync(pkgPath))
+        return [];
+      return fs.readdirSync(pkgPath).filter((v) => {
+        const meta = readMeta(path.join(pkgPath, v));
+        return meta !== null;
+      }).map((v) => ({
+        version: v,
+        pkgDir: path.join(pkgPath, v),
+        meta: readMeta(path.join(pkgPath, v))
+      }));
+    }
+    function pickVersion(cached, requestedVersion) {
+      if (!cached.length)
+        return null;
+      if (requestedVersion === "latest") {
+        return cached.sort(
+          (a, b) => new Date(b.meta.downloadedAt) - new Date(a.meta.downloadedAt)
+        )[0];
+      }
+      return cached.find((c) => c.version === requestedVersion) || null;
+    }
+    function runNpmInstall(tgzPath, saveFlag) {
+      const args = [
+        "install",
+        tgzPath,
+        "--prefer-offline",
+        // Use cache first before fetching
+        "--no-audit"
+        // Skip npm audit (requires network)
+      ];
+      if (saveFlag === "save")
+        args.push("--save");
+      if (saveFlag === "save-dev")
+        args.push("--save-dev");
+      const result = spawnSync("npm", args, {
+        encoding: "utf-8",
+        stdio: "inherit",
+        shell: true
+        // Windows compatibility
+      });
+      return result.status === 0;
+    }
+    function normalizeResolvedUrl(fileUri) {
+      if (typeof fileUri !== "string" || !fileUri.startsWith("file:"))
+        return null;
+      let absolute = fileUri.replace(/^file:\/\//, "").replace(/^file:/, "");
+      absolute = decodeURIComponent(absolute).replace(/\\/g, "/");
+      const marker = ".offline-npm-cache/";
+      const idx = absolute.indexOf(marker);
+      if (idx === -1)
+        return null;
+      const subpath = absolute.slice(idx + marker.length);
+      const parts = subpath.split("/").filter(Boolean);
+      let packageName;
+      let version2;
+      if (parts[0].startsWith("@")) {
+        if (parts.length < 4)
+          return null;
+        packageName = `${parts[0]}/${parts[1]}`;
+        version2 = parts[2];
+      } else {
+        if (parts.length < 3)
+          return null;
+        packageName = parts[0];
+        version2 = parts[1];
+      }
+      const baseName = packageName.includes("/") ? packageName.split("/").pop() : packageName;
+      const tarballName = `${baseName}-${version2}.tgz`;
+      return `https://registry.npmjs.org/${packageName}/-/${tarballName}`;
+    }
+    function sanitizePackageLock() {
+      const lockFile = path.resolve("package-lock.json");
+      if (!fs.existsSync(lockFile))
+        return;
+      try {
+        let sanitizeNode = function(node) {
+          if (!node || typeof node !== "object")
+            return;
+          if (node.resolved && typeof node.resolved === "string") {
+            const normalized = normalizeResolvedUrl(node.resolved);
+            if (normalized)
+              node.resolved = normalized;
+          }
+          if (node.dependencies && typeof node.dependencies === "object") {
+            for (const depName of Object.keys(node.dependencies)) {
+              sanitizeNode(node.dependencies[depName]);
+            }
+          }
+        };
+        const lockData = JSON.parse(fs.readFileSync(lockFile, "utf-8"));
+        if (lockData.packages && typeof lockData.packages === "object") {
+          for (const pkgPath of Object.keys(lockData.packages)) {
+            sanitizeNode(lockData.packages[pkgPath]);
+          }
+        }
+        if (lockData.dependencies && typeof lockData.dependencies === "object") {
+          sanitizeNode(lockData.dependencies);
+        }
+        fs.writeFileSync(lockFile, JSON.stringify(lockData, null, 2), "utf-8");
+      } catch (err) {
+        log.warn(`Could not sanitize package-lock.json: ${err.message}`);
+      }
+    }
+    function sanitizePackageJson(name, version2, saveFlag) {
+      if (!saveFlag)
+        return;
+      const pkgJsonPath = path.resolve("package.json");
+      if (!fs.existsSync(pkgJsonPath))
+        return;
+      try {
+        const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+        const section = saveFlag === "save-dev" ? "devDependencies" : "dependencies";
+        if (!pkgJson[section])
+          pkgJson[section] = {};
+        const current = pkgJson[section][name];
+        if (typeof current === "string" && current.startsWith("file:")) {
+          pkgJson[section][name] = version2;
+        }
+        console.log({ pkgJson });
+        fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2), "utf-8");
+      } catch (err) {
+        log.warn(`Could not sanitize package.json (${name}): ${err.message}`);
+      }
+    }
+    async function installPackage2(pkgInput, options) {
+      const { name, version: version2 } = parsePackage(pkgInput);
+      const storageDir = getStorageDir(options.storage);
+      log.header(`\u{1F4E6}  offline-npm install`);
+      log.info(
+        `Looking up ${log.bold(packageLabel(name, version2))} in local cache...`
+      );
+      log.dim(`Storage: ${storageDir}`);
+      console.log("");
+      const cached = findCachedVersions(storageDir, name);
+      if (!cached.length) {
+        log.error(`Package ${log.bold(name)} not found in local cache.`);
+        log.info(
+          `Run ${log.bold(`offline-npm add ${pkgInput}`)} while online first.`
+        );
+        process.exit(1);
+      }
+      const match = pickVersion(cached, version2);
+      if (!match) {
+        log.error(
+          `Version ${log.bold(version2)} of ${log.bold(name)} is not cached.`
+        );
+        log.info(`Cached versions: ${cached.map((c) => c.version).join(", ")}`);
+        log.info(
+          `Run ${log.bold(`offline-npm add ${pkgInput}`)} while online to download it.`
+        );
+        process.exit(1);
+      }
+      const tgzPath = path.join(match.pkgDir, match.meta.tgz);
+      if (!fs.existsSync(tgzPath)) {
+        log.error(`Cached .tgz file is missing: ${tgzPath}`);
+        log.info(
+          `Run ${log.bold(`offline-npm add ${pkgInput}`)} again to re-download.`
+        );
+        process.exit(1);
+      }
+      log.step(
+        `Installing ${log.bold(packageLabel(name, match.version))} from cache...`
+      );
+      log.dim(`Source: ${tgzPath}`);
+      console.log("");
+      const saveFlag = options.saveDev ? "save-dev" : options.save ? "save" : null;
+      const ok = runNpmInstall(tgzPath, saveFlag);
+      console.log("");
+      if (ok) {
+        log.success(
+          `Installed ${log.bold(packageLabel(name, match.version))} successfully (offline).`
+        );
+        sanitizePackageJson(name, match.version, saveFlag);
+        sanitizePackageLock();
+        log.info("Package metadata was rewritten to production-friendly sources.");
+      } else {
+        log.error(`npm install failed. Check output above for details.`);
+        process.exit(1);
+      }
+    }
+    module2.exports = { installPackage: installPackage2 };
+  }
+});
+
+// src/list.js
+var require_list = __commonJS({
+  "src/list.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var { getStorageDir, readMeta } = require_storage();
+    var log = require_logger();
+    function collectPackages(storageDir) {
+      const results = [];
+      function walk(dir, nameParts) {
+        if (!fs.existsSync(dir))
+          return;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory())
+            continue;
+          const fullPath = path.join(dir, entry.name);
+          if (nameParts.length === 0 && entry.name.startsWith("@")) {
+            walk(fullPath, [entry.name]);
+            continue;
+          }
+          if (nameParts.length === 0 || nameParts.length === 1 && nameParts[0].startsWith("@")) {
+            const pkgName = nameParts.length ? `${nameParts[0]}/${entry.name}` : entry.name;
+            walkVersions(fullPath, pkgName);
+          }
+        }
+      }
+      function walkVersions(pkgDir, pkgName) {
+        if (!fs.existsSync(pkgDir))
+          return;
+        const entries = fs.readdirSync(pkgDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory())
+            continue;
+          const versionDir = path.join(pkgDir, entry.name);
+          const meta = readMeta(versionDir);
+          if (meta) {
+            const tgzPath = path.join(versionDir, meta.tgz || "");
+            const tgzExists = fs.existsSync(tgzPath);
+            results.push({
+              id: `${pkgName}@${entry.name}`,
+              name: pkgName,
+              version: entry.name,
+              size: meta.size || 0,
+              sizeLabel: meta.size ? `${(meta.size / 1024).toFixed(1)} KB` : "?",
+              downloadedAt: meta.downloadedAt || null,
+              tgz: meta.tgz || null,
+              tgzPath,
+              status: tgzExists ? "ready" : "missing",
+              hasDeps: meta.hasDeps || false
+            });
+          }
+        }
+      }
+      walk(storageDir, []);
+      return results.sort(
+        (a, b) => new Date(b.downloadedAt) - new Date(a.downloadedAt)
+      );
+    }
+    async function listPackages2(options) {
+      const storageDir = getStorageDir(options.storage);
+      log.header("\u{1F4E6}  offline-npm list");
+      log.dim(`Storage: ${storageDir}`);
+      console.log("");
+      const packages = collectPackages(storageDir);
+      if (!packages.length) {
+        log.warn("No packages cached yet.");
+        log.info(
+          `Run ${log.bold("offline-npm add <package>")} to download packages.`
+        );
+        return;
+      }
+      const displayTable = packages.map((p) => ({
+        Package: p.name,
+        Version: p.version,
+        Size: p.sizeLabel,
+        Downloaded: p.downloadedAt ? new Date(p.downloadedAt).toLocaleString() : "?",
+        Status: p.status === "ready" ? "\u2714 ready" : "\u2716 missing"
+      }));
+      log.table(displayTable);
+      console.log("");
+      log.success(
+        `${packages.length} package version${packages.length === 1 ? "" : "s"} in cache.`
+      );
+    }
+    module2.exports = { listPackages: listPackages2, collectPackages };
+  }
+});
+
+// src/remove.js
+var require_remove = __commonJS({
+  "src/remove.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var { parsePackage, packageLabel } = require_parser();
+    var { getStorageDir } = require_storage();
+    var log = require_logger();
+    function rmDir(dir) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+    async function removePackage2(pkgInput, options) {
+      const { name, version: version2 } = parsePackage(pkgInput);
+      const storageDir = getStorageDir(options.storage);
+      log.header("\u{1F4E6}  offline-npm remove");
+      const nameParts = name.startsWith("@") ? name.split("/") : [name];
+      const pkgDir = path.join(storageDir, ...nameParts);
+      if (!fs.existsSync(pkgDir)) {
+        log.error(`Package ${log.bold(name)} is not in the local cache.`);
+        process.exit(1);
+      }
+      if (version2 === "latest") {
+        rmDir(pkgDir);
+        log.success(`Removed all cached versions of ${log.bold(name)}.`);
+      } else {
+        const versionDir = path.join(pkgDir, version2);
+        if (!fs.existsSync(versionDir)) {
+          log.error(
+            `Version ${log.bold(version2)} of ${log.bold(name)} is not cached.`
+          );
+          process.exit(1);
+        }
+        rmDir(versionDir);
+        log.success(`Removed ${log.bold(packageLabel(name, version2))} from cache.`);
+        try {
+          if (fs.readdirSync(pkgDir).length === 0)
+            fs.rmdirSync(pkgDir);
+          if (name.startsWith("@")) {
+            const scopeDir = path.join(storageDir, nameParts[0]);
+            if (fs.existsSync(scopeDir) && fs.readdirSync(scopeDir).length === 0) {
+              fs.rmdirSync(scopeDir);
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    module2.exports = { removePackage: removePackage2 };
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "offline-npm-manager",
+      version: "1.0.5",
+      description: "Download npm packages online, install them offline later",
+      bin: {
+        "offline-npm": "./dist/cli.cjs"
+      },
+      scripts: {
+        build: "esbuild bin/offline-npm.js --bundle --platform=node --format=cjs --outfile=dist/cli.cjs --external:commander",
+        prepublishOnly: "npm run build",
+        test: "node test/test.js",
+        dev: "node ./bin/offline-npm.js",
+        start: "npm run dev"
+      },
+      keywords: [
+        "npm",
+        "offline",
+        "package-manager",
+        "cli",
+        "offline-package-manager",
+        "offline-install",
+        "npm-cache",
+        "node-cli",
+        "dependency-cache",
+        "dependency-manager",
+        "offline-first"
+      ],
+      author: "Sagor Ahamed",
+      license: "MIT",
+      files: [
+        "bin",
+        "dist"
+      ],
+      dependencies: {
+        commander: "^11.1.0"
+      },
+      devDependencies: {
+        esbuild: "^0.19.0"
+      },
+      engines: {
+        node: ">=16.0.0"
+      },
+      postuninstall: `node -e "const fs=require('fs');const path=require('path');const os=require('os');const dir=path.join(os.homedir(),'.offline-npm-cache');if(fs.existsSync(dir))fs.rmSync(dir,{recursive:true,force:true});"`,
+      repository: {
+        type: "git",
+        url: "https://github.com/SagorAhamed251245/offline-npm-manager.git"
+      },
+      bugs: {
+        url: "https://github.com/SagorAhamed251245/offline-npm-manager/issues"
+      },
+      homepage: "https://github.com/SagorAhamed251245",
+      publishConfig: {
+        access: "public"
+      },
+      contributors: [
+        {
+          name: "Sagor Ahamed",
+          url: "https://github.com/SagorAhamed251245"
+        }
+      ],
+      funding: [
+        {
+          type: "github",
+          url: "https://github.com/sponsors/SagorAhamed251245"
+        }
+      ]
+    };
+  }
+});
+
+// bin/offline-npm.js
+var { program } = require("commander");
+var { addPackage } = require_add();
+var { installPackage } = require_install();
+var { listPackages } = require_list();
+var { removePackage } = require_remove();
+var { version } = require_package();
+program.name("offline-npm").description(
+  "\u{1F4E6} Download npm packages when online, install them offline later"
+).version(version);
+program.command("add <package>").description("Download a package and store it locally (requires internet)").option("-d, --deps", "Also download all dependencies recursively", false).option("-s, --storage <path>", "Custom storage directory").action(async (pkg, options) => {
+  await addPackage(pkg, options);
+});
+program.command("install <package>").description("Install a package from local offline storage").option("-s, --storage <path>", "Custom storage directory").option("--save", "Add to package.json dependencies", false).option("--save-dev", "Add to package.json devDependencies", false).action(async (pkg, options) => {
+  await installPackage(pkg, options);
+});
+program.command("list").alias("ls").description("List all locally stored packages").option("-s, --storage <path>", "Custom storage directory").action(async (options) => {
+  await listPackages(options);
+});
+program.command("remove <package>").alias("rm").description("Remove a package from local offline storage").option("-s, --storage <path>", "Custom storage directory").action(async (pkg, options) => {
+  await removePackage(pkg, options);
+});
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "offline-npm-manager",
+  "version": "1.0.5",
+  "description": "Download npm packages online, install them offline later",
+  "bin": {
+    "offline-npm": "./dist/cli.cjs"
+  },
+  "scripts": {
+    "build": "esbuild bin/offline-npm.js --bundle --platform=node --format=cjs --outfile=dist/cli.cjs --external:commander",
+    "prepublishOnly": "npm run build",
+    "test": "node test/test.js",
+    "dev": "node ./bin/offline-npm.js",
+    "start": "npm run dev"
+  },
+  "keywords": [
+    "npm",
+    "offline",
+    "package-manager",
+    "cli",
+    "offline-package-manager",
+    "offline-install",
+    "npm-cache",
+    "node-cli",
+    "dependency-cache",
+    "dependency-manager",
+    "offline-first"
+  ],
+  "author": "Sagor Ahamed",
+  "license": "MIT",
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^11.1.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.19.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "postuninstall": "node -e \"const fs=require('fs');const path=require('path');const os=require('os');const dir=path.join(os.homedir(),'.offline-npm-cache');if(fs.existsSync(dir))fs.rmSync(dir,{recursive:true,force:true});\"",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SagorAhamed251245/offline-npm-manager.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SagorAhamed251245/offline-npm-manager/issues"
+  },
+  "homepage": "https://github.com/SagorAhamed251245",
+  "publishConfig": {
+    "access": "public"
+  },
+  "contributors": [
+    {
+      "name": "Sagor Ahamed",
+      "url": "https://github.com/SagorAhamed251245"
+    }
+  ],
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/SagorAhamed251245"
+    }
+  ]
+}