@naesofteak/naeso 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Naesofteak Private Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,47 @@
-# Temporary Holding Version
+# Naeso
+
+**Naeso** is a package manager for macOS developed and maintained by **Naesofteak Private Limited**.
+
+Naeso provides a simple command-line interface for discovering, installing, verifying, managing, and running software packages on macOS.
+
+The project is designed to support both **Intel (x86_64)** and **Apple Silicon (arm64)** Macs.
+
+---
+
+## Features
+
+- Package search
+- Package information
+- Package compatibility detection
+- Automatic architecture detection
+- Version-aware package resolution
+- Download progress display
+- SHA-256 verification where official checksums are available
+- Multi-artifact package installation
+- Automatic installation directory management
+- Automatic PATH configuration
+- Package uninstall
+- macOS `launchd` service management
+- Package status management
+- Intel and Apple Silicon support
+- Local package cache
+
+---
+
+## Requirements
+
+- macOS
+- Node.js 18 or newer
+- Intel (x86_64) or Apple Silicon (arm64)
+- Internet connection for downloading packages
+
+---
+
+## Installation
+
+Install Naeso globally using npm:
+
+```bash
+npm install -g @naesofteak/naeso
+
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@naesofteak/naeso",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Naesofteak Package Manager for macOS",
+  "main": "src/index.js",
+  "type": "commonjs",
+  "bin": {
+    "naeso": "src/index.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node src/index.js --help"
+  },
+  "keywords": [
+    "naeso",
+    "naesofteak",
+    "package-manager",
+    "macos",
+    "installer",
+    "cli",
+    "mongodb",
+    "node",
+    "nginx",
+    "redis"
+  ],
+  "author": "Naesofteak Private Limited",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^15.0.0"
+  },
+  "homepage": "https://github.com/naesofteak/naeso#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/naesofteak/naeso.git"
+  },
+  "bugs": {
+    "url": "https://github.com/naesofteak/naeso/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/core/cache.js

@@ -0,0 +1,39 @@
+const fs = require("fs");
+const path = require("path");
+
+const CACHE_ROOT = path.join(
+  process.env.HOME,
+  ".naeso",
+  "cache"
+);
+
+function getPackageCachePath(packageName) {
+  return path.join(
+    CACHE_ROOT,
+    packageName
+  );
+}
+
+function ensurePackageCache(packageName) {
+  const cachePath =
+    getPackageCachePath(packageName);
+
+  fs.mkdirSync(cachePath, {
+    recursive: true
+  });
+
+  return cachePath;
+}
+
+function getCachedFile(packageName, filename) {
+  return path.join(
+    getPackageCachePath(packageName),
+    filename
+  );
+}
+
+module.exports = {
+  getPackageCachePath,
+  ensurePackageCache,
+  getCachedFile
+};

package/src/core/checksum.js

@@ -0,0 +1,33 @@
+const fs = require("fs");
+const crypto = require("crypto");
+
+function calculateSHA256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+
+    stream.on("data", (data) => {
+      hash.update(data);
+    });
+
+    stream.on("end", () => {
+      resolve(hash.digest("hex"));
+    });
+
+    stream.on("error", reject);
+  });
+}
+
+async function verifySHA256(filePath, expectedHash) {
+  const actualHash = await calculateSHA256(filePath);
+
+  return (
+    actualHash.toLowerCase() ===
+    expectedHash.toLowerCase()
+  );
+}
+
+module.exports = {
+  calculateSHA256,
+  verifySHA256
+};

package/src/core/compatibility.js

@@ -0,0 +1,152 @@
+function getLatestVersion(pkg) {
+  const versions = Object.keys(
+    pkg.versions || {}
+  );
+
+  if (versions.length === 0) {
+    return null;
+  }
+
+  return versions.sort(compareVersions).at(-1);
+}
+
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const av = pa[i] || 0;
+    const bv = pb[i] || 0;
+
+    if (av !== bv) {
+      return av - bv;
+    }
+  }
+
+  return 0;
+}
+
+function getVersionConfig(
+  pkg,
+  version = null
+) {
+  const selectedVersion =
+    version || getLatestVersion(pkg);
+
+  if (!selectedVersion) {
+    return null;
+  }
+
+  const config =
+    pkg.versions[selectedVersion];
+
+  if (!config) {
+    return null;
+  }
+
+  return {
+    version: selectedVersion,
+    config
+  };
+}
+
+function isPackageSupported(
+  pkg,
+  target,
+  version = null
+) {
+  const versionConfig =
+    getVersionConfig(pkg, version);
+
+  if (!versionConfig) {
+    return false;
+  }
+
+  const targetConfig =
+    versionConfig.config.targets?.[target];
+
+  if (!targetConfig) {
+    return false;
+  }
+
+  /*
+   * Multi-artifact package
+   */
+  if (targetConfig.artifacts) {
+    const artifacts =
+      Object.values(targetConfig.artifacts);
+
+    return (
+      artifacts.length > 0 &&
+      artifacts.every(
+        (artifact) =>
+          artifact &&
+          typeof artifact.url === "string" &&
+          artifact.url.length > 0
+      )
+    );
+  }
+
+  /*
+   * Legacy single-artifact package
+   */
+  return Boolean(
+    targetConfig.url
+  );
+}
+
+function getSupportedTargets(
+  pkg,
+  version = null
+) {
+  const versionConfig =
+    getVersionConfig(pkg, version);
+
+  if (!versionConfig) {
+    return [];
+  }
+
+  return Object.keys(
+    versionConfig.config.targets || {}
+  );
+}
+
+function getArtifacts(
+  pkg,
+  target,
+  version = null
+) {
+  const versionConfig =
+    getVersionConfig(pkg, version);
+
+  if (!versionConfig) {
+    return null;
+  }
+
+  const targetConfig =
+    versionConfig.config.targets?.[target];
+
+  if (!targetConfig) {
+    return null;
+  }
+
+  if (targetConfig.artifacts) {
+    return targetConfig.artifacts;
+  }
+
+  if (targetConfig.url) {
+    return {
+      default: targetConfig
+    };
+  }
+
+  return null;
+}
+
+module.exports = {
+  getLatestVersion,
+  getVersionConfig,
+  isPackageSupported,
+  getSupportedTargets,
+  getArtifacts
+};

package/src/core/downloader.js

@@ -0,0 +1,234 @@
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const http = require("http");
+
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+
+  const units = ["B", "KB", "MB", "GB"];
+  const index = Math.floor(
+    Math.log(bytes) / Math.log(1024)
+  );
+
+  return `${(
+    bytes / Math.pow(1024, index)
+  ).toFixed(index === 0 ? 0 : 1)} ${units[index]}`;
+}
+
+function formatTime(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) {
+    return "--";
+  }
+
+  if (seconds < 60) {
+    return `${Math.ceil(seconds)}s`;
+  }
+
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds =
+    Math.ceil(seconds % 60);
+
+  return `${minutes}m ${remainingSeconds}s`;
+}
+
+function renderProgress(
+  filename,
+  downloaded,
+  total,
+  speed,
+  eta
+) {
+  const width = 40;
+
+  const percentage =
+    total > 0
+      ? downloaded / total
+      : 0;
+
+  const completed =
+    Math.round(width * percentage);
+
+  const remaining =
+    width - completed;
+
+  const bar =
+    "█".repeat(completed) +
+    "░".repeat(remaining);
+
+  const percentText =
+    `${(percentage * 100).toFixed(0)}%`;
+
+  const line =
+    `Downloading ${filename}\n` +
+    `[${bar}] ${percentText}  ` +
+    `${formatBytes(downloaded)} / ` +
+    `${formatBytes(total)}\n` +
+    `Speed: ${formatBytes(speed)}/s  ` +
+    `ETA: ${formatTime(eta)}`;
+
+  process.stdout.write(
+    `\r\x1b[3A\x1b[0J${line}`
+  );
+}
+
+function downloadFile(url, destination) {
+  return new Promise((resolve, reject) => {
+
+    const protocol =
+      url.startsWith("https://")
+        ? https
+        : http;
+
+    const directory =
+      path.dirname(destination);
+
+    fs.mkdirSync(directory, {
+      recursive: true
+    });
+
+    const request =
+      protocol.get(url, (response) => {
+
+        // --------------------------------
+        // Redirect
+        // --------------------------------
+
+        if (
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          response.resume();
+
+          return downloadFile(
+            response.headers.location,
+            destination
+          )
+            .then(resolve)
+            .catch(reject);
+        }
+
+        // --------------------------------
+        // HTTP error
+        // --------------------------------
+
+        if (response.statusCode !== 200) {
+          response.resume();
+
+          return reject(
+            new Error(
+              `Download failed: HTTP ${response.statusCode}`
+            )
+          );
+        }
+
+        // --------------------------------
+        // Existing file protection
+        // --------------------------------
+
+        let file;
+
+        try {
+          file = fs.createWriteStream(
+            destination,
+            {
+              flags: "wx"
+            }
+          );
+        } catch (error) {
+          return reject(error);
+        }
+
+        const total =
+          Number(
+            response.headers["content-length"]
+          ) || 0;
+
+        let downloaded = 0;
+
+        const startTime =
+          Date.now();
+
+        console.log("");
+        console.log("");
+        console.log("");
+
+        response.on("data", (chunk) => {
+
+          downloaded += chunk.length;
+
+          const elapsed =
+            (Date.now() - startTime) / 1000;
+
+          const speed =
+            elapsed > 0
+              ? downloaded / elapsed
+              : 0;
+
+          const remaining =
+            total > downloaded
+              ? total - downloaded
+              : 0;
+
+          const eta =
+            speed > 0
+              ? remaining / speed
+              : Infinity;
+
+          renderProgress(
+            path.basename(destination),
+            downloaded,
+            total,
+            speed,
+            eta
+          );
+        });
+
+        response.pipe(file);
+
+        response.on("end", () => {
+          process.stdout.write("\n\n");
+        });
+
+        file.on("finish", () => {
+
+          file.close(() => {
+            resolve(destination);
+          });
+        });
+
+        file.on("error", (error) => {
+
+          file.close();
+
+          fs.unlink(
+            destination,
+            () => {}
+          );
+
+          reject(error);
+        });
+      });
+
+    request.setTimeout(
+      30000,
+      () => {
+        request.destroy(
+          new Error(
+            "Download timed out."
+          )
+        );
+      }
+    );
+
+    request.on(
+      "error",
+      reject
+    );
+  });
+}
+
+module.exports = {
+  downloadFile
+};