@rstreamlabs/rstream-cli 1.0.0 → 1.1.0

package/README.md

@@ -0,0 +1,3 @@
+# @rstreamlabs/cli
+
+Powerful Tunnels for Modern Applications.

package/package.json

@@ -1,32 +1,21 @@
 {
   "name": "@rstreamlabs/rstream-cli",
-  "version": "1.0.0",
-  "description": "Powerful Tunnels for Modern Applications.",
+  "version": "1.1.0",
+  "description": "Command-line interface for rstream.",
   "author": "@uartnet <hello@rstream.io>",
   "license": "Apache-2.0",
   "homepage": "https://rstream.io",
-  "keywords": [
-    "networking",
-    "enterprise",
-    "secure",
-    "scalable",
-    "serverless",
-    "developpers",
-    "devops",
-    "sysadmins",
-    "infrastructure",
-    "cloud"
-  ],
   "main": "dist/main.js",
   "bin": {
     "rstream": "dist/main.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "scripts": {
     "format": "prettier --write \"**/*.{ts,tsx,md}\"",
-    "install": "node -r adm-zip -r tar dist/install.js",
+    "install": "rstream-installer",
     "prepack": "bash -c \"! [[ -d dist ]] || rm -r dist\" && tsc",
     "type-check": "tsc --noEmit"
   },
@@ -34,18 +23,16 @@
   "engines": {
     "node": ">=12"
   },
-  "dependencies": {
-    "adm-zip": "^0.5.16",
-    "tar": "^7.4.3"
-  },
-  "rstream": {
+  "@rstreamlabs/installer": {
+    "name": "rstream",
     "channel": "stable",
     "registry": "https://rstream.io"
   },
+  "dependencies": {
+    "@rstreamlabs/installer": "^1.0.2"
+  },
   "devDependencies": {
-    "@types/adm-zip": "^0.5.7",
-    "@types/node": "^22.15.21",
-    "@types/tar": "^6.1.13",
+    "@types/node": "^22.15.28",
     "prettier": "^3.5.3",
     "tsx": "4.19.4",
     "typescript": "^5.8.3"

package/dist/install.js

@@ -1,201 +0,0 @@
-#!/usr/bin/env node
-import { createGunzip } from "node:zlib";
-import AdmZip from "adm-zip";
-import fs from "fs";
-import https from "https";
-import os from "os";
-import path from "path";
-import * as tar from "tar";
-const name = "rstream";
-const npm_package_json = process.env.npm_package_json;
-if (npm_package_json === undefined) {
-    console.error("npm_package_json environment variable is not set. Please run this script from an npm script.");
-    process.exit(1);
-}
-const dirname = path.dirname(npm_package_json);
-const config = JSON.parse(fs.readFileSync(path.resolve(npm_package_json), "utf8"));
-const channel = config.rstream.channel;
-const version = config.version;
-const registry = config.rstream.registry;
-function getOS() {
-    const platform = os.platform();
-    switch (platform) {
-        case "win32":
-            return "windows";
-        case "darwin":
-            return "macos";
-        case "linux":
-            return "linux";
-        case "freebsd":
-            return "freebsd";
-        case "netbsd":
-            return "netbsd";
-        case "openbsd":
-            return "openbsd";
-        default:
-            throw new Error(`Unsupported platform '${platform}'`);
-    }
-}
-function getArch() {
-    const machine = os.arch();
-    switch (machine) {
-        case "ppc64":
-            return "ppc64";
-        case "mips":
-            return "mips";
-        case "mipsel":
-            return "mipsle";
-        case "arm":
-            return "armv6";
-        case "arm64":
-            return "arm64";
-        case "x64":
-            return "x86_64";
-        case "ia32":
-            return "x86_i686";
-        default:
-            throw new Error(`Unsupported architecture '${machine}'`);
-    }
-}
-async function getPackageId(registry, name, version, channel, os, arch) {
-    return new Promise((resolve, reject) => {
-        const url = `${registry}/api/packages?name=${name}&version=${version}&channel=${channel}&os=${os}&arch=${arch}&format=plain`;
-        https
-            .get(url, (response) => {
-            let data = "";
-            response.on("data", (chunk) => {
-                data += chunk;
-            });
-            response.on("end", () => {
-                if (response.statusCode === 200) {
-                    const lines = data.split("\r\n");
-                    if (lines.length > 0) {
-                        const id = lines[0].split(":")[0];
-                        resolve(id);
-                    }
-                    else {
-                        reject(new Error("No package ID found in the response"));
-                    }
-                }
-                else {
-                    reject(new Error(`Failed to fetch package ID : ${response.statusCode}`));
-                }
-            });
-        })
-            .on("error", (err) => {
-            reject(err);
-        });
-    });
-}
-async function download(url, dst, redirects = 5) {
-    return new Promise((resolve, reject) => {
-        if (redirects === 0) {
-            reject(new Error("Too many redirects"));
-        }
-        else {
-            https
-                .get(url, async (response) => {
-                const location = response.headers.location;
-                if (location !== undefined) {
-                    response.on("data", () => { });
-                    response.on("end", async () => {
-                        await download(location, dst, redirects - 1)
-                            .then(resolve)
-                            .catch(reject);
-                    });
-                }
-                else if (response.statusCode !== 200) {
-                    reject(new Error(`Failed to download file : server responded with status code ${response.statusCode}`));
-                }
-                else {
-                    const file = fs.createWriteStream(dst);
-                    file.on("error", (err) => {
-                        file.close(() => {
-                            reject(err);
-                        });
-                    });
-                    file.on("finish", () => {
-                        file.close(() => {
-                            resolve();
-                        });
-                    });
-                    response.pipe(file);
-                }
-            })
-                .on("error", (err) => {
-                reject(err);
-            });
-        }
-    });
-}
-function rmSync(dir) {
-    if (fs.existsSync(dir)) {
-        fs.readdirSync(dir).forEach((file) => {
-            const current = path.join(dir, file);
-            if (fs.lstatSync(current).isDirectory()) {
-                rmSync(current);
-            }
-            else {
-                fs.unlinkSync(current);
-            }
-        });
-        fs.rmdirSync(dir);
-    }
-}
-async function extract(src, dst) {
-    rmSync(dst);
-    fs.mkdirSync(dst, { recursive: true });
-    return new Promise((resolve, reject) => {
-        const extname = src.endsWith(".tar.gz") ? ".tar.gz" : path.extname(src);
-        if (extname === ".zip") {
-            return new Promise((resolve, reject) => {
-                try {
-                    const zip = new AdmZip(src);
-                    zip.extractAllTo(dst, true);
-                    resolve();
-                }
-                catch (err) {
-                    reject(err);
-                }
-            });
-        }
-        else if (extname === ".tar.gz") {
-            const extractor = tar.extract({ cwd: dst });
-            fs.createReadStream(src)
-                .pipe(createGunzip())
-                .pipe(extractor)
-                .on("error", reject);
-            extractor.on("finish", resolve);
-        }
-        else {
-            reject(new Error(`Unsupported archive format '${extname}'`));
-        }
-    });
-}
-async function install() {
-    try {
-        const platform = getOS();
-        const arch = getArch();
-        const id = await getPackageId(registry, name, version, channel, platform, arch);
-        console.log("Installation summary :");
-        console.log(`Package name    : ${name}`);
-        console.log(`Package version : ${version}`);
-        console.log(`Package channel : ${channel}`);
-        console.log(`OS              : ${platform}`);
-        console.log(`Arch            : ${arch}`);
-        console.log(`Package ID      : ${id}`);
-        console.log(`Downloading and installing ${name} version '${version}'...`);
-        const url = `${registry}/api/packages/${id}/download`;
-        const dst = path.join(os.tmpdir(), `${name}-${version}-${os}-${arch}.${platform === "windows" ? "zip" : "tar.gz"}`);
-        await download(url, dst);
-        await extract(dst, path.resolve(dirname, "release"));
-        fs.unlinkSync(dst);
-        console.log(`Installation successful!`);
-    }
-    catch (err) {
-        console.error(`Installation failed : ${err}`);
-        process.exit(1);
-    }
-}
-install();
-export default install;