Make latest build, fix windows download url and fix tests

volodymyrZotov · volodymyrZotov · commit 3eed3f1da26a · 2025-07-24T16:18:05.000-05:00
diff --git a/dist/index.js b/dist/index.js
@@ -32666,26 +32666,36 @@ var tool_cache = __nccwpck_require__(3472);
 
 
 
+// maps OS architecture names to 1Password CLI installer architecture names
 const archMap = {
     ia32: "386",
-    x32: "386",
-    x86: "386",
     x64: "amd64",
     arm: "arm",
     arm64: "arm64",
 };
+// Builds the download URL for the 1Password CLI based on the platform and version.
+const cliUrlBuilder = {
+    linux: (version, arch) => `https://cache.agilebits.com/dist/1P/op2/pkg/${version}/op_linux_${arch}_${version}.zip`,
+    darwin: (version) => `https://cache.agilebits.com/dist/1P/op2/pkg/${version}/op_apple_universal_${version}.pkg`,
+    win32: (version, arch) => `https://cache.agilebits.com/dist/1P/op2/pkg/${version}/op_windows_${arch}_${version}.zip`,
+};
 class CliInstaller {
-    async install(downloadUrl) {
-        console.info(`Downloading 1Password CLI from: ${downloadUrl}`);
-        const downloadPath = await tool_cache.downloadTool(downloadUrl);
+    version;
+    arch;
+    constructor(version) {
+        this.version = version;
+        this.arch = this.getArch();
+    }
+    async install(url) {
+        console.info(`Downloading 1Password CLI from: ${url}`);
+        const downloadPath = await tool_cache.downloadTool(url);
         console.info("Installing 1Password CLI");
         const extractedPath = await tool_cache.extractZip(downloadPath);
         core.addPath(extractedPath);
         core.info("1Password CLI installed");
     }
-    // possible values for GitHub hosted runners (process.env.RUNNER_ARCH) can be found here: https://docs.github.com/en/actions/reference/variables-reference#default-environment-variables
     getArch() {
-        const arch = archMap[process.env.RUNNER_ARCH?.toLowerCase() || external_os_default().arch()];
+        const arch = archMap[external_os_default().arch()];
         if (!arch) {
             throw new Error("Unsupported architecture");
         }
@@ -32695,21 +32705,14 @@ class CliInstaller {
 
 ;// CONCATENATED MODULE: ./src/cli-installer/linux.ts
 
-
 class LinuxInstaller extends CliInstaller {
-    arch;
-    version;
+    platform = "linux"; // Node.js platform identifier for Linux
     constructor(version) {
-        super();
-        this.version = version;
-        this.arch = super.getArch();
+        super(version);
     }
     async installCli() {
-        const downloadUrl = this.downloadUrl();
-        await super.install(downloadUrl);
-    }
-    downloadUrl() {
-        return `https://cache.agilebits.com/dist/1P/op2/pkg/${this.version}/op_linux_${this.arch}_${this.version}.zip`;
+        const urlBuilder = cliUrlBuilder[this.platform];
+        await super.install(urlBuilder(this.version, this.arch));
     }
 }
 
@@ -32732,18 +32735,13 @@ var external_util_ = __nccwpck_require__(9023);
 
 const execAsync = (0,external_util_.promisify)(external_child_process_.exec);
 class MacOsInstaller extends CliInstaller {
-    version;
+    platform = "darwin"; // Node.js platform identifier for macOS
     constructor(version) {
-        super();
-        this.version = version;
+        super(version);
     }
     async installCli() {
-        const downloadUrl = this.downloadUrl();
-        core.info(`Downloading 1Password CLI ${this.version} from ${downloadUrl}`);
-        await this.install(downloadUrl);
-    }
-    downloadUrl() {
-        return `https://cache.agilebits.com/dist/1P/op2/pkg/${this.version}/op_apple_universal_${this.version}.pkg`;
+        const urlBuilder = cliUrlBuilder[this.platform];
+        await this.install(urlBuilder(this.version));
     }
     // @actions/tool-cache package does not support .pkg files, so we need to handle the installation manually
     async install(downloadUrl) {
@@ -32766,36 +32764,37 @@ class MacOsInstaller extends CliInstaller {
 ;// CONCATENATED MODULE: ./src/cli-installer/windows.ts
 
 class WindowsInstaller extends CliInstaller {
-    arch;
-    version;
+    platform = "win32"; // Node.js platform identifier for Windows
     constructor(version) {
-        super();
-        this.version = version;
-        this.arch = super.getArch();
+        super(version);
     }
     async installCli() {
-        const downloadUrl = this.downloadUrl();
-        await super.install(downloadUrl);
-    }
-    downloadUrl() {
-        return `https://cache.agilebits.com/dist/1P/op2/pkg/${this.version}/op_windows_${this.arch}_${this.version}.zip`;
+        const urlBuilder = cliUrlBuilder[this.platform];
+        await super.install(urlBuilder(this.version, this.arch));
     }
 }
 
-;// CONCATENATED MODULE: ./src/cli-installer/index.ts
+;// CONCATENATED MODULE: ./src/cli-installer/installer.ts
 
 
 
-/* eslint-disable @typescript-eslint/naming-convention */
-// RunnerOS defines the operating system of the runner executing the job.
-// Look `RUNNER_OS` for possible values (https://docs.github.com/en/actions/reference/variables-reference).
-var RunnerOS;
-(function (RunnerOS) {
-    RunnerOS["Linux"] = "Linux";
-    RunnerOS["MacOS"] = "macOS";
-    RunnerOS["Windows"] = "Windows";
-})(RunnerOS || (RunnerOS = {}));
-/* eslint-enable @typescript-eslint/naming-convention */
+
+const newCliInstaller = (version) => {
+    const platform = external_os_default().platform();
+    switch (platform) {
+        case "linux":
+            return new LinuxInstaller(version);
+        case "darwin":
+            return new MacOsInstaller(version);
+        case "win32":
+            return new WindowsInstaller(version);
+        default:
+            throw new Error(`Unsupported platform: ${platform}`);
+    }
+};
+
+;// CONCATENATED MODULE: ./src/cli-installer/index.ts
+
 
 ;// CONCATENATED MODULE: ./src/version/constants.ts
 /* eslint-disable @typescript-eslint/naming-convention */
@@ -32900,21 +32899,7 @@ const run = async () => {
     try {
         const versionResolver = new VersionResolver(core.getInput("version"));
         await versionResolver.resolve();
-        let installer;
-        switch (process.env.RUNNER_OS) {
-            case RunnerOS.Linux:
-                installer = new LinuxInstaller(versionResolver.get());
-                break;
-            case RunnerOS.MacOS:
-                installer = new MacOsInstaller(versionResolver.get());
-                break;
-            case RunnerOS.Windows:
-                installer = new WindowsInstaller(versionResolver.get());
-                break;
-            default:
-                core.setFailed(`Unsupported platform: ${process.env.RUNNER_OS}`);
-                return;
-        }
+        const installer = newCliInstaller(versionResolver.get());
         await installer.installCli();
     }
     catch (error) {
diff --git a/src/cli-installer/cli-installer.ts b/src/cli-installer/cli-installer.ts
@@ -9,7 +9,7 @@ export type SupportedPlatform = Extract<
 >;
 
 // maps OS architecture names to 1Password CLI installer architecture names
-const archMap: Record<string, string> = {
+export const archMap: Record<string, string> = {
 	ia32: "386",
 	x64: "amd64",
 	arm: "arm",
@@ -26,7 +26,7 @@ export const cliUrlBuilder: Record<
 	darwin: (version) =>
 		`https://cache.agilebits.com/dist/1P/op2/pkg/${version}/op_apple_universal_${version}.pkg`,
 	win32: (version, arch) =>
-		`https://cache.agilebits.com/dist/1P/op2/pkg/${version}/op_windows_${arch}_${version}_.zip`,
+		`https://cache.agilebits.com/dist/1P/op2/pkg/${version}/op_windows_${arch}_${version}.zip`,
 };
 
 export class CliInstaller {
diff --git a/src/cli-installer/installer.test.ts b/src/cli-installer/installer.test.ts
@@ -5,10 +5,9 @@ import { LinuxInstaller } from "./linux";
 import { MacOsInstaller } from "./macos";
 import { WindowsInstaller } from "./windows";
 
-jest.mock("os");
-jest.mock("./linux");
-jest.mock("./macos");
-jest.mock("./windows");
+afterEach(() => {
+	jest.restoreAllMocks();
+});
 
 describe("newCliInstaller", () => {
 	const version = "1.0.0";
@@ -18,25 +17,25 @@ describe("newCliInstaller", () => {
 	});
 
 	it("should return LinuxInstaller for linux platform", () => {
-		(os.platform as jest.Mock).mockReturnValue("linux");
+		jest.spyOn(os, "platform").mockReturnValue("linux");
 		const installer = newCliInstaller(version);
 		expect(installer).toBeInstanceOf(LinuxInstaller);
 	});
 
 	it("should return MacOsInstaller for darwin platform", () => {
-		(os.platform as jest.Mock).mockReturnValue("darwin");
+		jest.spyOn(os, "platform").mockReturnValue("darwin");
 		const installer = newCliInstaller(version);
 		expect(installer).toBeInstanceOf(MacOsInstaller);
 	});
 
 	it("should return WindowsInstaller for win32 platform", () => {
-		(os.platform as jest.Mock).mockReturnValue("win32");
+		jest.spyOn(os, "platform").mockReturnValue("win32");
 		const installer = newCliInstaller(version);
 		expect(installer).toBeInstanceOf(WindowsInstaller);
 	});
 
 	it("should throw error for unsupported platform", () => {
-		(os.platform as jest.Mock).mockReturnValue("sunos");
+		jest.spyOn(os, "platform").mockReturnValue("sunos");
 		expect(() => newCliInstaller(version)).toThrow(
 			"Unsupported platform: sunos",
 		);
diff --git a/src/cli-installer/linux.test.ts b/src/cli-installer/linux.test.ts
@@ -1,19 +1,26 @@
 import os from "os";
 
 import {
+	archMap,
 	CliInstaller,
 	cliUrlBuilder,
 	type SupportedPlatform,
 } from "./cli-installer";
 import { LinuxInstaller } from "./linux";
 
+afterEach(() => {
+	jest.restoreAllMocks();
+});
+
 describe("LinuxInstaller", () => {
 	const version = "1.2.3";
+	const arch: NodeJS.Architecture = "arm64";
 
 	it("should construct with given version and architecture", () => {
+		jest.spyOn(os, "arch").mockReturnValue(arch);
 		const installer = new LinuxInstaller(version);
 		expect(installer.version).toEqual(version);
-		expect(installer.arch).toEqual(os.arch());
+		expect(installer.arch).toEqual(archMap[arch]);
 	});
 
 	it("should call install with correct URL", async () => {
diff --git a/src/cli-installer/macos.test.ts b/src/cli-installer/macos.test.ts
@@ -1,15 +1,25 @@
 import os from "os";
 
-import { cliUrlBuilder, type SupportedPlatform } from "./cli-installer";
+import {
+	archMap,
+	cliUrlBuilder,
+	type SupportedPlatform,
+} from "./cli-installer";
 import { MacOsInstaller } from "./macos";
 
+afterEach(() => {
+	jest.restoreAllMocks();
+});
+
 describe("MacOsInstaller", () => {
 	const version = "1.2.3";
+	const arch: NodeJS.Architecture = "x64";
 
 	it("should construct with given version and architecture", () => {
+		jest.spyOn(os, "arch").mockReturnValue(arch);
 		const installer = new MacOsInstaller(version);
 		expect(installer.version).toEqual(version);
-		expect(installer.arch).toEqual(os.arch());
+		expect(installer.arch).toEqual(archMap[arch]);
 	});
 
 	it("should call install with correct URL", async () => {
diff --git a/src/cli-installer/windows.test.ts b/src/cli-installer/windows.test.ts
@@ -1,19 +1,26 @@
 import os from "os";
 
 import {
+	archMap,
 	CliInstaller,
 	cliUrlBuilder,
 	type SupportedPlatform,
 } from "./cli-installer";
 import { WindowsInstaller } from "./windows";
 
+afterEach(() => {
+	jest.restoreAllMocks();
+});
+
 describe("WindowsInstaller", () => {
 	const version = "1.2.3";
+	const arch: NodeJS.Architecture = "x64";
 
 	it("should construct with given version and architecture", () => {
+		jest.spyOn(os, "arch").mockReturnValue(arch);
 		const installer = new WindowsInstaller(version);
 		expect(installer.version).toEqual(version);
-		expect(installer.arch).toEqual(os.arch());
+		expect(installer.arch).toEqual(archMap[arch]);
 	});
 
 	it("should call install with correct URL", async () => {
