inngest-cli 0.5.1

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "inngest-cli",
+  "version": "0.5.1",
+  "description": "The event-driven queue for any language.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "scripts": {
+    "prepublishOnly": "mkdir bin && touch bin/inngest",
+    "postinstall": "node postinstall.js",
+    "build": "tsc"
+  },
+  "bin": {
+    "inngest": "./bin/inngest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/inngest/inngest.git"
+  },
+  "homepage": "https://github.com/inngest/inngest",
+  "files": [
+    "bin",
+    "LICENSE.md",
+    "postinstall.js"
+  ],
+  "volta": {
+    "node": "16.16.0"
+  },
+  "dependencies": {
+    "node-fetch": "2.6.7",
+    "tar": "6.1.11",
+    "unzipper": "0.10.11"
+  },
+  "devDependencies": {
+    "@types/node-fetch": "2.6.2",
+    "@types/request": "2.48.8",
+    "@types/tar": "6.1.1",
+    "@types/unzipper": "0.10.5",
+    "typescript": "4.7.4"
+  }
+}

package/postinstall.js

@@ -0,0 +1,115 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const path_1 = __importDefault(require("path"));
+const tar_1 = __importDefault(require("tar"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const url_1 = require("url");
+const archMap = {
+    arm64: "arm64",
+    x64: "x86_64",
+};
+var KnownExtension;
+(function (KnownExtension) {
+    KnownExtension["Tar"] = ".tar.gz";
+    KnownExtension["Zip"] = ".zip";
+})(KnownExtension || (KnownExtension = {}));
+const platformMap = {
+    linux: { platform: "linux", extension: KnownExtension.Tar },
+    darwin: { platform: "darwin", extension: KnownExtension.Tar },
+    win32: { platform: "windows", extension: KnownExtension.Zip },
+};
+function getBinaryUrl() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const version = (_a = process.env.npm_package_version) === null || _a === void 0 ? void 0 : _a.trim();
+        if (!version) {
+            throw new Error("Could not find package version to install binary");
+        }
+        const { arch, platform } = getArchPlatform();
+        const targetUrl = new url_1.URL(`https://cli.inngest.com/artifact/v${version}/inngest_${version}_${platform.platform}_${arch}${platform.extension}`);
+        return targetUrl;
+    });
+}
+function getArchPlatform() {
+    const arch = archMap[process.arch];
+    const platform = platformMap[process.platform];
+    if (!arch) {
+        throw new Error(`Unsupported architecture: ${process.arch}`);
+    }
+    if (!platform) {
+        throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+    return { arch, platform };
+}
+function downloadBinary(url) {
+    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        (0, node_fetch_1.default)(url.href, {
+            redirect: "follow",
+        })
+            .then((res) => {
+            if (res.status !== 200) {
+                throw new Error(`Error downloading binary; invalid response status code: ${res.status}`);
+            }
+            resolve(res);
+        })
+            .catch(reject);
+    }));
+}
+function pipeBinaryToInstallLocation(res, originalUrl) {
+    return new Promise((resolve, reject) => {
+        if (!res.body) {
+            return reject(new Error("No body to pipe"));
+        }
+        const targetPath = path_1.default.resolve("./bin");
+        const strategies = {
+            [KnownExtension.Tar]: () => {
+                var _a;
+                const untar = tar_1.default.extract({ cwd: targetPath });
+                untar.on("error", reject);
+                untar.on("end", () => resolve());
+                (_a = res.body) === null || _a === void 0 ? void 0 : _a.pipe(untar);
+            },
+            [KnownExtension.Zip]: () => {
+                var _a;
+                const unzip = unzipper_1.default.Extract({ path: targetPath });
+                unzip.on("error", reject);
+                unzip.on("close", () => resolve());
+                (_a = res.body) === null || _a === void 0 ? void 0 : _a.pipe(unzip);
+            },
+        };
+        const [, strategy] = Object.entries(strategies).find(([knownExt]) => {
+            return originalUrl.pathname.endsWith(knownExt);
+        }) || [, null];
+        if (!strategy) {
+            return reject(new Error("Unsupported extension"));
+        }
+        strategy();
+    });
+}
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    if (process.env.SKIP_POSTINSTALL) {
+        process.exit(0);
+    }
+    try {
+        const binaryUrl = yield getBinaryUrl();
+        const req = yield downloadBinary(binaryUrl);
+        yield pipeBinaryToInstallLocation(req, binaryUrl);
+    }
+    catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}))();