🎩 You're Invited:Meet the Socket team at Black Hat in Las Vegas, August 3-6.RSVP →

@aptos-labs/aptos-cli

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@aptos-labs/aptos-cli - npm Package Compare versions

Comparing version

1.1.1

2.0.0

+69

dist/examples/examples.test.js

		import { existsSync, readFileSync } from "node:fs";
		import { join } from "node:path";
		import { describe, expect, it } from "vitest";
		const WORKSPACE_ROOT = join(__dirname, "../..");
		const EXAMPLES_DIR = join(WORKSPACE_ROOT, "examples");
		const HELLO_BLOCKCHAIN_DIR = join(EXAMPLES_DIR, "hello_blockchain");
		describe("Example Move Projects", () => {
		describe("hello_blockchain example", () => {
		it("should have Move.toml configuration file", () => {
		const moveTomlPath = join(HELLO_BLOCKCHAIN_DIR, "Move.toml");
		expect(existsSync(moveTomlPath)).toBe(true);
		const content = readFileSync(moveTomlPath, "utf-8");
		expect(content).toContain("[package]");
		expect(content).toContain('name = "HelloBlockchain"');
		expect(content).toContain("[addresses]");
		expect(content).toContain("hello_blockchain");
		expect(content).toContain("[dependencies.AptosFramework]");
		});
		it("should have source files", () => {
		const sourcesDir = join(HELLO_BLOCKCHAIN_DIR, "sources");
		expect(existsSync(sourcesDir)).toBe(true);
		const messageMovePath = join(sourcesDir, "message.move");
		expect(existsSync(messageMovePath)).toBe(true);
		});
		it("should have valid Move module structure", () => {
		const messageMovePath = join(HELLO_BLOCKCHAIN_DIR, "sources/message.move");
		const content = readFileSync(messageMovePath, "utf-8");
		expect(content).toContain("module hello_blockchain::message");
		expect(content).toContain("public entry fun");
		expect(content).toContain("has key");
		expect(content).toContain("#[test");
		});
		});
		});
		describe("Build Move Artifacts Workflow", () => {
		const workflowPath = join(WORKSPACE_ROOT, ".github/workflows/build-move-artifacts.yaml");
		it("should have the workflow file", () => {
		expect(existsSync(workflowPath)).toBe(true);
		});
		it("should contain required workflow configuration", () => {
		const content = readFileSync(workflowPath, "utf-8");
		expect(content).toContain("name: Build Move Artifacts");
		expect(content).toContain("on:");
		expect(content).toContain("jobs:");
		expect(content).toContain("Install Aptos CLI");
		expect(content).toContain("--install");
		expect(content).toContain("Build Move package");
		expect(content).toContain("move compile");
		expect(content).toContain("--named-addresses");
		expect(content).toContain("--save-metadata");
		expect(content).toContain("Generate publish payload");
		expect(content).toContain("build-publish-payload");
		expect(content).toContain("--json-output-file");
		expect(content).toContain("Upload build artifacts");
		expect(content).toContain("actions/upload-artifact");
		});
		it("should have artifact download job for downstream usage", () => {
		const content = readFileSync(workflowPath, "utf-8");
		expect(content).toContain("use-artifacts");
		expect(content).toContain("needs: build-artifacts");
		expect(content).toContain("actions/download-artifact");
		});
		it("should demonstrate upgrade payload generation", () => {
		const content = readFileSync(workflowPath, "utf-8");
		expect(content).toContain("build-upgrade-payload");
		expect(content).toContain("--object-address");
		});
		});
		//# sourceMappingURL=examples.test.js.map

+1

dist/examples/examples.test.js.map

+227

dist/tasks/install.test.js

		import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
		vi.mock("child_process", () => ({
		execSync: vi.fn(),
		}));
		vi.mock("fs", () => ({
		existsSync: vi.fn(),
		chmodSync: vi.fn(),
		mkdirSync: vi.fn(),
		}));
		vi.mock("os", () => ({
		tmpdir: () => "/tmp",
		homedir: () => "/home/user",
		platform: vi.fn(() => "linux"),
		arch: vi.fn(() => "x64"),
		}));
		vi.mock("../utils/getUserOs.js", () => ({
		getOS: vi.fn(),
		getTargetPlatform: vi.fn(),
		}));
		vi.mock("../utils/getLocalBinPath.js", () => ({
		getLocalBinPath: vi.fn(),
		getBinDir: vi.fn(),
		invalidateBinPathCache: vi.fn(),
		}));
		vi.mock("../utils/ghOperations.js", () => ({
		getCliVersion: vi.fn(),
		hasUserSpecifiedVersion: vi.fn(),
		}));
		vi.mock("../utils/brewOperations.js", () => ({
		isBrewAvailable: vi.fn(),
		isInstalledViaBrew: vi.fn(),
		installViaBrew: vi.fn(),
		}));
		vi.mock("../utils/windowsPackageManagers.js", () => ({
		isWingetAvailable: vi.fn(),
		isChocoAvailable: vi.fn(),
		isInstalledViaWinget: vi.fn(),
		isInstalledViaChoco: vi.fn(),
		installViaWinget: vi.fn(),
		installViaChoco: vi.fn(),
		}));
		import { execSync } from "node:child_process";
		import { existsSync, mkdirSync } from "node:fs";
		import { installViaBrew, isBrewAvailable, isInstalledViaBrew, } from "../utils/brewOperations.js";
		import { getBinDir, getLocalBinPath } from "../utils/getLocalBinPath.js";
		import { getOS, getTargetPlatform } from "../utils/getUserOs.js";
		import { getCliVersion, hasUserSpecifiedVersion, } from "../utils/ghOperations.js";
		import { installViaChoco, installViaWinget, isChocoAvailable, isInstalledViaChoco, isInstalledViaWinget, isWingetAvailable, } from "../utils/windowsPackageManagers.js";
		import { installCli } from "./install.js";
		describe("install", () => {
		beforeEach(() => {
		vi.clearAllMocks();
		vi.mocked(getLocalBinPath).mockReturnValue("/home/user/.local/bin/aptos");
		vi.mocked(getBinDir).mockReturnValue("/home/user/.local/bin");
		vi.mocked(getCliVersion).mockResolvedValue("1.0.0");
		vi.mocked(hasUserSpecifiedVersion).mockReturnValue(false);
		vi.mocked(getTargetPlatform).mockReturnValue("Linux-x86_64");
		});
		afterEach(() => {
		vi.restoreAllMocks();
		});
		describe("macOS with Homebrew", () => {
		beforeEach(() => {
		vi.mocked(getOS).mockReturnValue("MacOS");
		vi.mocked(isBrewAvailable).mockReturnValue(true);
		});
		it("should use Homebrew when available", async () => {
		vi.mocked(isInstalledViaBrew).mockReturnValue(false);
		await installCli();
		expect(installViaBrew).toHaveBeenCalled();
		expect(execSync).not.toHaveBeenCalled();
		});
		it("should skip if already installed via Homebrew", async () => {
		vi.mocked(isInstalledViaBrew).mockReturnValue(true);
		await installCli();
		expect(installViaBrew).not.toHaveBeenCalled();
		});
		it("should skip Homebrew when directDownload is true", async () => {
		vi.mocked(isInstalledViaBrew).mockReturnValue(false);
		vi.mocked(existsSync).mockReturnValue(false);
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		vi.mocked(getTargetPlatform).mockReturnValue("macos-x86_64");
		await installCli(true);
		expect(installViaBrew).not.toHaveBeenCalled();
		expect(execSync).toHaveBeenCalled();
		});
		});
		describe("Windows with winget", () => {
		beforeEach(() => {
		vi.mocked(getOS).mockReturnValue("Windows");
		vi.mocked(isBrewAvailable).mockReturnValue(false);
		vi.mocked(isWingetAvailable).mockReturnValue(true);
		vi.mocked(isChocoAvailable).mockReturnValue(false);
		});
		it("should use winget when available", async () => {
		vi.mocked(isInstalledViaWinget).mockReturnValue(false);
		await installCli();
		expect(installViaWinget).toHaveBeenCalled();
		expect(installViaChoco).not.toHaveBeenCalled();
		});
		it("should skip if already installed via winget", async () => {
		vi.mocked(isInstalledViaWinget).mockReturnValue(true);
		await installCli();
		expect(installViaWinget).not.toHaveBeenCalled();
		});
		});
		describe("Windows with Chocolatey", () => {
		beforeEach(() => {
		vi.mocked(getOS).mockReturnValue("Windows");
		vi.mocked(isBrewAvailable).mockReturnValue(false);
		vi.mocked(isWingetAvailable).mockReturnValue(false);
		vi.mocked(isChocoAvailable).mockReturnValue(true);
		});
		it("should use Chocolatey when winget is not available", async () => {
		vi.mocked(isInstalledViaChoco).mockReturnValue(false);
		await installCli();
		expect(installViaChoco).toHaveBeenCalled();
		expect(installViaWinget).not.toHaveBeenCalled();
		});
		it("should skip if already installed via Chocolatey", async () => {
		vi.mocked(isInstalledViaChoco).mockReturnValue(true);
		await installCli();
		expect(installViaChoco).not.toHaveBeenCalled();
		});
		});
		describe("Windows direct download", () => {
		beforeEach(() => {
		vi.mocked(getOS).mockReturnValue("Windows");
		vi.mocked(isBrewAvailable).mockReturnValue(false);
		vi.mocked(isWingetAvailable).mockReturnValue(false);
		vi.mocked(isChocoAvailable).mockReturnValue(false);
		vi.mocked(existsSync).mockReturnValue(false);
		vi.mocked(getTargetPlatform).mockReturnValue("Windows-x86_64");
		});
		it("should download directly when no package manager available", async () => {
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		await installCli();
		expect(installViaWinget).not.toHaveBeenCalled();
		expect(installViaChoco).not.toHaveBeenCalled();
		expect(execSync).toHaveBeenCalledWith(expect.stringContaining("powershell"), expect.any(Object));
		});
		it("should skip package managers when directDownload is true", async () => {
		vi.mocked(isWingetAvailable).mockReturnValue(true);
		vi.mocked(isChocoAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		await installCli(true);
		expect(installViaWinget).not.toHaveBeenCalled();
		expect(installViaChoco).not.toHaveBeenCalled();
		expect(execSync).toHaveBeenCalled();
		});
		});
		describe("Linux direct download", () => {
		beforeEach(() => {
		vi.mocked(getOS).mockReturnValue("Linux");
		vi.mocked(isBrewAvailable).mockReturnValue(false);
		vi.mocked(existsSync).mockReturnValue(false);
		vi.mocked(getTargetPlatform).mockReturnValue("Ubuntu-22.04-x86_64");
		});
		it("should download directly on Linux", async () => {
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		await installCli();
		expect(execSync).toHaveBeenCalledWith(expect.stringContaining("curl"), expect.any(Object));
		});
		it("should create bin directory if it doesn't exist", async () => {
		vi.mocked(existsSync).mockImplementation((path) => {
		if (path === "/home/user/.local/bin")
		return false;
		return false;
		});
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		await installCli();
		expect(mkdirSync).toHaveBeenCalledWith("/home/user/.local/bin", {
		recursive: true,
		});
		});
		});
		describe("already installed", () => {
		it("should skip if binary already exists", async () => {
		vi.mocked(getOS).mockReturnValue("Linux");
		vi.mocked(isBrewAvailable).mockReturnValue(false);
		vi.mocked(existsSync).mockReturnValue(true);
		await installCli();
		expect(execSync).not.toHaveBeenCalled();
		expect(getCliVersion).not.toHaveBeenCalled();
		});
		});
		describe("specific version via APTOS_CLI_VERSION", () => {
		beforeEach(() => {
		vi.mocked(hasUserSpecifiedVersion).mockReturnValue(true);
		vi.mocked(getCliVersion).mockResolvedValue("4.5.0");
		});
		it("should skip package managers when specific version is set", async () => {
		vi.mocked(getOS).mockReturnValue("MacOS");
		vi.mocked(isBrewAvailable).mockReturnValue(true);
		vi.mocked(isInstalledViaBrew).mockReturnValue(false);
		vi.mocked(existsSync).mockReturnValue(false);
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		vi.mocked(getTargetPlatform).mockReturnValue("macos-x86_64");
		await installCli();
		expect(installViaBrew).not.toHaveBeenCalled();
		expect(execSync).toHaveBeenCalled();
		});
		it("should skip winget when specific version is set on Windows", async () => {
		vi.mocked(getOS).mockReturnValue("Windows");
		vi.mocked(isBrewAvailable).mockReturnValue(false);
		vi.mocked(isWingetAvailable).mockReturnValue(true);
		vi.mocked(isChocoAvailable).mockReturnValue(true);
		vi.mocked(existsSync).mockReturnValue(false);
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		vi.mocked(getTargetPlatform).mockReturnValue("Windows-x86_64");
		await installCli();
		expect(installViaWinget).not.toHaveBeenCalled();
		expect(installViaChoco).not.toHaveBeenCalled();
		expect(execSync).toHaveBeenCalled();
		});
		it("should use specific version in download URL", async () => {
		vi.mocked(getOS).mockReturnValue("Linux");
		vi.mocked(isBrewAvailable).mockReturnValue(false);
		vi.mocked(existsSync).mockReturnValue(false);
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		vi.mocked(getTargetPlatform).mockReturnValue("Ubuntu-22.04-x86_64");
		await installCli();
		expect(execSync).toHaveBeenCalledWith(expect.stringContaining("4.5.0"), expect.any(Object));
		});
		});
		});
		//# sourceMappingURL=install.test.js.map

+1

dist/tasks/install.test.js.map

+92

dist/tasks/run.test.js

		import { EventEmitter } from "node:events";
		import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
		const createMockChildProcess = () => {
		const emitter = new EventEmitter();
		return emitter;
		};
		let mockChildProcess;
		vi.mock("child_process", () => ({
		spawn: vi.fn(() => mockChildProcess),
		}));
		vi.mock("fs", () => ({
		existsSync: vi.fn(),
		}));
		vi.mock("../utils/getUserOs.js", () => ({
		getPlatformInfo: vi.fn(() => ({ os: "linux", arch: "x64" })),
		}));
		vi.mock("../utils/getLocalBinPath.js", () => ({
		getLocalBinPath: vi.fn(() => "/home/user/.local/bin/aptos"),
		}));
		import { spawn } from "node:child_process";
		import { existsSync } from "node:fs";
		import { runCLI } from "./run.js";
		describe("run", () => {
		const mockExit = vi.fn();
		beforeEach(() => {
		vi.clearAllMocks();
		mockChildProcess = createMockChildProcess();
		vi.stubGlobal("process", {
		...process,
		exit: mockExit,
		});
		});
		afterEach(() => {
		vi.unstubAllGlobals();
		});
		describe("runCLI", () => {
		it("should spawn the CLI with provided arguments", async () => {
		vi.mocked(existsSync).mockReturnValue(true);
		await runCLI(["info", "--verbose"]);
		expect(spawn).toHaveBeenCalledWith("/home/user/.local/bin/aptos", ["info", "--verbose"], expect.objectContaining({
		stdio: "inherit",
		}));
		});
		it("should use custom binary path when provided", async () => {
		vi.mocked(existsSync).mockReturnValue(true);
		await runCLI(["info"], "/custom/path/aptos");
		expect(spawn).toHaveBeenCalledWith("/custom/path/aptos", ["info"], expect.any(Object));
		});
		it("should exit with non-zero code when child process exits with non-zero code", async () => {
		vi.mocked(existsSync).mockReturnValue(true);
		await runCLI(["invalid-command"]);
		mockChildProcess.emit("exit", 1);
		expect(mockExit).toHaveBeenCalledWith(1);
		});
		it("should exit with the exact exit code from child process", async () => {
		vi.mocked(existsSync).mockReturnValue(true);
		await runCLI(["some-command"]);
		mockChildProcess.emit("exit", 42);
		expect(mockExit).toHaveBeenCalledWith(42);
		});
		it("should not call process.exit when child process exits with code 0", async () => {
		vi.mocked(existsSync).mockReturnValue(true);
		await runCLI(["info"]);
		mockChildProcess.emit("exit", 0);
		expect(mockExit).not.toHaveBeenCalled();
		});
		it("should not call process.exit when child process exits with null code", async () => {
		vi.mocked(existsSync).mockReturnValue(true);
		await runCLI(["info"]);
		mockChildProcess.emit("exit", null);
		expect(mockExit).not.toHaveBeenCalled();
		});
		it("should print error and exit if custom binary path does not exist", async () => {
		vi.mocked(existsSync).mockReturnValue(false);
		const consoleSpy = vi
		.spyOn(console, "error")
		.mockImplementation(() => { });
		await runCLI(["info"], "/nonexistent/path/aptos");
		expect(consoleSpy).toHaveBeenCalledWith("Error: Binary not found at specified path: /nonexistent/path/aptos");
		expect(mockExit).toHaveBeenCalledWith(1);
		expect(spawn).not.toHaveBeenCalled();
		});
		it("should print install message if default binary does not exist", async () => {
		vi.mocked(existsSync).mockReturnValue(false);
		const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
		await runCLI(["info"]);
		expect(consoleSpy).toHaveBeenCalledWith("Aptos CLI not installed, run `npx aptos --install` to install");
		expect(spawn).not.toHaveBeenCalled();
		});
		});
		});
		//# sourceMappingURL=run.test.js.map

+1

dist/tasks/run.test.js.map

+83

dist/utils/brewOperations.test.js

		import { execSync } from "node:child_process";
		import { existsSync } from "node:fs";
		import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
		vi.mock("child_process", () => ({
		execSync: vi.fn(),
		}));
		vi.mock("fs", () => ({
		existsSync: vi.fn(),
		}));
		vi.mock("./executableIsAvailable.js", () => ({
		executableIsAvailable: vi.fn(),
		}));
		import { getCliPathBrew, installViaBrew, isBrewAvailable, isInstalledViaBrew, updateViaBrew, } from "./brewOperations.js";
		import { executableIsAvailable } from "./executableIsAvailable.js";
		describe("brewOperations", () => {
		beforeEach(() => {
		vi.clearAllMocks();
		});
		afterEach(() => {
		vi.restoreAllMocks();
		});
		describe("isBrewAvailable", () => {
		it("should return true when brew is available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		expect(isBrewAvailable()).toBe(true);
		expect(executableIsAvailable).toHaveBeenCalledWith("brew");
		});
		it("should return false when brew is not available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(false);
		expect(isBrewAvailable()).toBe(false);
		});
		});
		describe("isInstalledViaBrew", () => {
		it("should return true when aptos is installed via brew", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockReturnValue("/opt/homebrew/Cellar/aptos");
		vi.mocked(existsSync).mockReturnValue(true);
		expect(isInstalledViaBrew()).toBe(true);
		});
		it("should return false when brew is not available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(false);
		expect(isInstalledViaBrew()).toBe(false);
		});
		it("should return false when aptos path doesn't exist", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockReturnValue("/opt/homebrew/Cellar/aptos");
		vi.mocked(existsSync).mockReturnValue(false);
		expect(isInstalledViaBrew()).toBe(false);
		});
		it("should return false when brew --prefix throws", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockImplementation(() => {
		throw new Error("aptos not installed");
		});
		expect(isInstalledViaBrew()).toBe(false);
		});
		});
		describe("getCliPathBrew", () => {
		it("should return the correct path", () => {
		vi.mocked(execSync).mockReturnValue("/opt/homebrew/Cellar/aptos\n");
		expect(getCliPathBrew()).toBe("/opt/homebrew/Cellar/aptos/bin/aptos");
		});
		});
		describe("installViaBrew", () => {
		it("should call brew install aptos", () => {
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		installViaBrew();
		expect(execSync).toHaveBeenCalledWith("brew install aptos", {
		stdio: "inherit",
		});
		});
		});
		describe("updateViaBrew", () => {
		it("should call brew upgrade aptos", () => {
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		updateViaBrew();
		expect(execSync).toHaveBeenCalledWith("brew upgrade aptos", {
		stdio: "inherit",
		});
		});
		});
		});
		//# sourceMappingURL=brewOperations.test.js.map

+1

dist/utils/brewOperations.test.js.map

+12

dist/utils/executableIsAvailable.js

		import { execSync } from "node:child_process";
		export const executableIsAvailable = (name) => {
		try {
		const command = process.platform === "win32" ? `where ${name}` : `which ${name}`;
		execSync(command, { encoding: "utf8", stdio: "pipe" });
		return true;
		}
		catch {
		return false;
		}
		};
		//# sourceMappingURL=executableIsAvailable.js.map

+1

dist/utils/executableIsAvailable.js.map

{"version":3,"file":"executableIsAvailable.js","sourceRoot":"","sources":["../../bin/utils/executableIsAvailable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAM9C,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,IAAY,EAAW,EAAE;IAC7D,IAAI,CAAC;QACH,MAAM,OAAO,GACX,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,IAAI,EAAE,CAAC;QACnE,QAAQ,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QACvD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC","sourcesContent":["import { execSync } from \"node:child_process\";\n\n/**\n * Check if an executable is available on the system.\n * Uses `which` on Unix systems (macOS/Linux) and `where` on Windows.\n */\nexport const executableIsAvailable = (name: string): boolean => {\n try {\n const command =\n process.platform === \"win32\" ? `where ${name}` : `which ${name}`;\n execSync(command, { encoding: \"utf8\", stdio: \"pipe\" });\n return true;\n } catch {\n return false;\n }\n};\n"]}

+143

dist/utils/getUserOs.test.js

		import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
		vi.mock("os", async () => {
		const actual = await vi.importActual("os");
		return {
		...actual,
		platform: vi.fn(),
		arch: vi.fn(),
		};
		});
		vi.mock("fs", async () => {
		const actual = await vi.importActual("fs");
		return {
		...actual,
		existsSync: vi.fn(),
		readFileSync: vi.fn(),
		};
		});
		import { existsSync, readFileSync } from "node:fs";
		import { arch, platform } from "node:os";
		import { getOS, getPlatformInfo, getTargetPlatform } from "./getUserOs.js";
		describe("getUserOs", () => {
		beforeEach(() => {
		vi.clearAllMocks();
		});
		afterEach(() => {
		vi.restoreAllMocks();
		});
		describe("getPlatformInfo", () => {
		it("should detect macOS x86_64", () => {
		vi.mocked(platform).mockReturnValue("darwin");
		vi.mocked(arch).mockReturnValue("x64");
		const result = getPlatformInfo();
		expect(result).toEqual({ os: "macos", arch: "x86_64" });
		});
		it("should detect macOS ARM64", () => {
		vi.mocked(platform).mockReturnValue("darwin");
		vi.mocked(arch).mockReturnValue("arm64");
		const result = getPlatformInfo();
		expect(result).toEqual({ os: "macos", arch: "aarch64" });
		});
		it("should detect Linux x86_64", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("x64");
		const result = getPlatformInfo();
		expect(result).toEqual({ os: "linux", arch: "x86_64" });
		});
		it("should detect Linux ARM64", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("arm64");
		const result = getPlatformInfo();
		expect(result).toEqual({ os: "linux", arch: "aarch64" });
		});
		it("should detect Windows x86_64", () => {
		vi.mocked(platform).mockReturnValue("win32");
		vi.mocked(arch).mockReturnValue("x64");
		const result = getPlatformInfo();
		expect(result).toEqual({ os: "windows", arch: "x86_64" });
		});
		it("should throw for unsupported OS", () => {
		vi.mocked(platform).mockReturnValue("freebsd");
		vi.mocked(arch).mockReturnValue("x64");
		expect(() => getPlatformInfo()).toThrow("Unsupported operating system");
		});
		it("should throw for unsupported architecture", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("mips");
		expect(() => getPlatformInfo()).toThrow("Unsupported architecture");
		});
		});
		describe("getTargetPlatform", () => {
		it("should return macos-x86_64 for Intel Mac", () => {
		vi.mocked(platform).mockReturnValue("darwin");
		vi.mocked(arch).mockReturnValue("x64");
		expect(getTargetPlatform()).toBe("macos-x86_64");
		});
		it("should return macos-arm64 for Apple Silicon Mac", () => {
		vi.mocked(platform).mockReturnValue("darwin");
		vi.mocked(arch).mockReturnValue("arm64");
		expect(getTargetPlatform()).toBe("macos-arm64");
		});
		it("should return Ubuntu-24.04-x86_64 for Ubuntu 24.04", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("x64");
		vi.mocked(existsSync).mockReturnValue(true);
		vi.mocked(readFileSync).mockReturnValue('ID=ubuntu\nVERSION_ID="24.04"\n');
		expect(getTargetPlatform()).toBe("Ubuntu-24.04-x86_64");
		});
		it("should return Ubuntu-22.04-x86_64 for Ubuntu 22.04", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("x64");
		vi.mocked(existsSync).mockReturnValue(true);
		vi.mocked(readFileSync).mockReturnValue('ID=ubuntu\nVERSION_ID="22.04"\n');
		expect(getTargetPlatform()).toBe("Ubuntu-22.04-x86_64");
		});
		it("should return Linux-x86_64 for non-Ubuntu Linux", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("x64");
		vi.mocked(existsSync).mockReturnValue(true);
		vi.mocked(readFileSync).mockReturnValue('ID=fedora\nVERSION_ID="39"\n');
		expect(getTargetPlatform()).toBe("Linux-x86_64");
		});
		it("should return Linux-x86_64 when /etc/os-release doesn't exist", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("x64");
		vi.mocked(existsSync).mockReturnValue(false);
		expect(getTargetPlatform()).toBe("Linux-x86_64");
		});
		it("should return Linux-aarch64 for ARM64 Linux", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("arm64");
		vi.mocked(existsSync).mockReturnValue(false);
		expect(getTargetPlatform()).toBe("Linux-aarch64");
		});
		it("should return Windows-x86_64 for Windows", () => {
		vi.mocked(platform).mockReturnValue("win32");
		vi.mocked(arch).mockReturnValue("x64");
		expect(getTargetPlatform()).toBe("Windows-x86_64");
		});
		it("should throw for Windows ARM64", () => {
		vi.mocked(platform).mockReturnValue("win32");
		vi.mocked(arch).mockReturnValue("arm64");
		expect(() => getTargetPlatform()).toThrow("Windows ARM64 is not currently supported");
		});
		});
		describe("getOS", () => {
		it("should return MacOS for darwin", () => {
		vi.mocked(platform).mockReturnValue("darwin");
		vi.mocked(arch).mockReturnValue("x64");
		expect(getOS()).toBe("MacOS");
		});
		it("should return Linux for linux", () => {
		vi.mocked(platform).mockReturnValue("linux");
		vi.mocked(arch).mockReturnValue("x64");
		expect(getOS()).toBe("Linux");
		});
		it("should return Windows for win32", () => {
		vi.mocked(platform).mockReturnValue("win32");
		vi.mocked(arch).mockReturnValue("x64");
		expect(getOS()).toBe("Windows");
		});
		});
		});
		//# sourceMappingURL=getUserOs.test.js.map

+1

dist/utils/getUserOs.test.js.map

+217

dist/utils/ghOperations.test.js

		import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
		const mockFetch = vi.fn();
		global.fetch = mockFetch;
		import { getCliVersion, getLatestVersionGh, getUserSpecifiedVersion, hasUserSpecifiedVersion, validateVersionExists, } from "./ghOperations.js";
		describe("ghOperations", () => {
		beforeEach(() => {
		vi.clearAllMocks();
		delete process.env.GITHUB_TOKEN;
		delete process.env.APTOS_CLI_VERSION;
		});
		afterEach(() => {
		vi.restoreAllMocks();
		});
		describe("getLatestVersionGh", () => {
		it("should return the latest version", async () => {
		mockFetch.mockResolvedValue({
		ok: true,
		json: () => Promise.resolve([
		{ tag_name: "aptos-cli-v1.2.3" },
		{ tag_name: "aptos-cli-v1.2.2" },
		]),
		});
		const version = await getLatestVersionGh();
		expect(version).toBe("1.2.3");
		expect(mockFetch).toHaveBeenCalledWith("https://api.github.com/repos/aptos-labs/aptos-core/releases?per_page=100", expect.objectContaining({
		headers: expect.objectContaining({
		Accept: "application/vnd.github.v3+json",
		"User-Agent": "aptos-cli-npm",
		}),
		}));
		});
		it("should use GITHUB_TOKEN when available", async () => {
		process.env.GITHUB_TOKEN = "test-token";
		mockFetch.mockResolvedValue({
		ok: true,
		json: () => Promise.resolve([{ tag_name: "aptos-cli-v1.0.0" }]),
		});
		await getLatestVersionGh();
		expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
		headers: expect.objectContaining({
		Authorization: "Bearer test-token",
		}),
		}));
		});
		it("should skip non-CLI releases", async () => {
		mockFetch.mockResolvedValue({
		ok: true,
		json: () => Promise.resolve([
		{ tag_name: "other-release-v2.0.0" },
		{ tag_name: "aptos-cli-v1.5.0" },
		]),
		});
		const version = await getLatestVersionGh();
		expect(version).toBe("1.5.0");
		});
		it("should throw on rate limit (403)", async () => {
		mockFetch.mockResolvedValue({
		ok: false,
		status: 403,
		statusText: "Forbidden",
		});
		await expect(getLatestVersionGh()).rejects.toThrow("GitHub API rate limit exceeded");
		});
		it("should throw on rate limit (429)", async () => {
		mockFetch.mockResolvedValue({
		ok: false,
		status: 429,
		statusText: "Too Many Requests",
		});
		await expect(getLatestVersionGh()).rejects.toThrow("GitHub API rate limit exceeded");
		});
		it("should throw on other HTTP errors", async () => {
		mockFetch.mockResolvedValue({
		ok: false,
		status: 500,
		statusText: "Internal Server Error",
		});
		await expect(getLatestVersionGh()).rejects.toThrow("GitHub API request failed with status 500");
		});
		it("should throw on network error", async () => {
		mockFetch.mockRejectedValue(new Error("Network error"));
		await expect(getLatestVersionGh()).rejects.toThrow("Failed to fetch releases from GitHub");
		});
		it("should throw when no CLI release found", async () => {
		mockFetch.mockResolvedValue({
		ok: true,
		json: () => Promise.resolve([
		{ tag_name: "other-release-v1.0.0" },
		{ tag_name: "another-release-v2.0.0" },
		]),
		});
		await expect(getLatestVersionGh()).rejects.toThrow("Could not determine latest version of Aptos CLI");
		});
		it("should throw on invalid JSON response", async () => {
		mockFetch.mockResolvedValue({
		ok: true,
		json: () => Promise.reject(new Error("Invalid JSON")),
		});
		await expect(getLatestVersionGh()).rejects.toThrow("Failed to parse GitHub API response");
		});
		it("should throw when response is not an array", async () => {
		mockFetch.mockResolvedValue({
		ok: true,
		json: () => Promise.resolve({ message: "not an array" }),
		});
		await expect(getLatestVersionGh()).rejects.toThrow("Unexpected response format");
		});
		});
		describe("getUserSpecifiedVersion", () => {
		it("should return undefined when APTOS_CLI_VERSION is not set", () => {
		delete process.env.APTOS_CLI_VERSION;
		expect(getUserSpecifiedVersion()).toBeUndefined();
		});
		it("should return the version when APTOS_CLI_VERSION is set", () => {
		process.env.APTOS_CLI_VERSION = "1.2.3";
		expect(getUserSpecifiedVersion()).toBe("1.2.3");
		});
		it("should strip v prefix from version", () => {
		process.env.APTOS_CLI_VERSION = "v1.2.3";
		expect(getUserSpecifiedVersion()).toBe("1.2.3");
		});
		it("should handle version without v prefix", () => {
		process.env.APTOS_CLI_VERSION = "2.0.0";
		expect(getUserSpecifiedVersion()).toBe("2.0.0");
		});
		it("should accept pre-release versions", () => {
		process.env.APTOS_CLI_VERSION = "v1.2.3-rc.1";
		expect(getUserSpecifiedVersion()).toBe("1.2.3-rc.1");
		});
		it("should reject invalid version strings", () => {
		process.env.APTOS_CLI_VERSION = "not-a-version";
		expect(() => getUserSpecifiedVersion()).toThrow("Invalid APTOS_CLI_VERSION");
		});
		it("should reject version with shell metacharacters", () => {
		process.env.APTOS_CLI_VERSION = '1.0.0"; rm -rf /; echo "';
		expect(() => getUserSpecifiedVersion()).toThrow("Invalid APTOS_CLI_VERSION");
		});
		});
		describe("hasUserSpecifiedVersion", () => {
		it("should return false when APTOS_CLI_VERSION is not set", () => {
		delete process.env.APTOS_CLI_VERSION;
		expect(hasUserSpecifiedVersion()).toBe(false);
		});
		it("should return true when APTOS_CLI_VERSION is set", () => {
		process.env.APTOS_CLI_VERSION = "1.0.0";
		expect(hasUserSpecifiedVersion()).toBe(true);
		});
		it("should return false when APTOS_CLI_VERSION is empty string", () => {
		process.env.APTOS_CLI_VERSION = "";
		expect(hasUserSpecifiedVersion()).toBe(false);
		});
		});
		describe("validateVersionExists", () => {
		it("should return true when version exists", async () => {
		mockFetch.mockResolvedValue({ ok: true });
		const result = await validateVersionExists("1.0.0", "Linux-x86_64");
		expect(result).toBe(true);
		expect(mockFetch).toHaveBeenCalledWith("https://github.com/aptos-labs/aptos-core/releases/download/aptos-cli-v1.0.0/aptos-cli-1.0.0-Linux-x86_64.zip", expect.objectContaining({ method: "HEAD" }));
		});
		it("should return false when version does not exist", async () => {
		mockFetch.mockResolvedValue({ ok: false });
		const result = await validateVersionExists("99.99.99", "Linux-x86_64");
		expect(result).toBe(false);
		});
		it("should return false on network error", async () => {
		mockFetch.mockRejectedValue(new Error("Network error"));
		const result = await validateVersionExists("1.0.0", "Linux-x86_64");
		expect(result).toBe(false);
		});
		it("should use GITHUB_TOKEN when available", async () => {
		process.env.GITHUB_TOKEN = "test-token";
		mockFetch.mockResolvedValue({ ok: true });
		await validateVersionExists("1.0.0", "Linux-x86_64");
		expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
		headers: expect.objectContaining({
		Authorization: "Bearer test-token",
		}),
		}));
		});
		});
		describe("getCliVersion", () => {
		it("should return latest version when APTOS_CLI_VERSION is not set", async () => {
		delete process.env.APTOS_CLI_VERSION;
		mockFetch.mockResolvedValue({
		ok: true,
		json: () => Promise.resolve([{ tag_name: "aptos-cli-v2.0.0" }]),
		});
		const version = await getCliVersion();
		expect(version).toBe("2.0.0");
		});
		it("should return user-specified version when APTOS_CLI_VERSION is set", async () => {
		process.env.APTOS_CLI_VERSION = "1.5.0";
		const version = await getCliVersion();
		expect(version).toBe("1.5.0");
		expect(mockFetch).not.toHaveBeenCalled();
		});
		it("should validate version when targetPlatform is provided", async () => {
		process.env.APTOS_CLI_VERSION = "1.5.0";
		mockFetch.mockResolvedValue({ ok: true });
		const version = await getCliVersion("Linux-x86_64");
		expect(version).toBe("1.5.0");
		expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining("1.5.0"), expect.objectContaining({ method: "HEAD" }));
		});
		it("should throw error when specified version does not exist", async () => {
		process.env.APTOS_CLI_VERSION = "99.99.99";
		mockFetch.mockResolvedValue({ ok: false });
		await expect(getCliVersion("Linux-x86_64")).rejects.toThrow("Specified version 99.99.99 does not exist");
		});
		it("should strip v prefix and validate version", async () => {
		process.env.APTOS_CLI_VERSION = "v1.5.0";
		mockFetch.mockResolvedValue({ ok: true });
		const version = await getCliVersion("Linux-x86_64");
		expect(version).toBe("1.5.0");
		});
		});
		});
		//# sourceMappingURL=ghOperations.test.js.map

+1

dist/utils/ghOperations.test.js.map

+100

dist/utils/windowsPackageManagers.js

		import { execSync } from "node:child_process";
		import { existsSync } from "node:fs";
		import { executableIsAvailable } from "./executableIsAvailable.js";
		export const isWingetAvailable = () => {
		return executableIsAvailable("winget");
		};
		export const isChocoAvailable = () => {
		return executableIsAvailable("choco");
		};
		export const isInstalledViaWinget = () => {
		if (!isWingetAvailable()) {
		return false;
		}
		try {
		const output = execSync("winget list --id Aptos.Aptos", {
		encoding: "utf8",
		stdio: ["pipe", "pipe", "pipe"],
		});
		return output.includes("Aptos.Aptos");
		}
		catch {
		return false;
		}
		};
		export const isInstalledViaChoco = () => {
		if (!isChocoAvailable()) {
		return false;
		}
		try {
		const output = execSync("choco list aptos", {
		encoding: "utf8",
		stdio: ["pipe", "pipe", "pipe"],
		});
		return output.toLowerCase().includes("aptos");
		}
		catch {
		return false;
		}
		};
		export const getCliPathWinget = () => {
		const possiblePaths = [
		`${process.env.LOCALAPPDATA}\\Microsoft\\WinGet\\Packages\\Aptos.Aptos_Microsoft.Winget.Source_8wekyb3d8bbwe\\aptos.exe`,
		`${process.env.PROGRAMFILES}\\Aptos\\aptos.exe`,
		`${process.env.LOCALAPPDATA}\\Aptos\\aptos.exe`,
		];
		for (const path of possiblePaths) {
		if (path && existsSync(path)) {
		return path;
		}
		}
		try {
		const output = execSync("where aptos", {
		encoding: "utf8",
		stdio: ["pipe", "pipe", "pipe"],
		}).trim();
		if (output && existsSync(output.split("\n")[0])) {
		return output.split("\n")[0];
		}
		}
		catch {
		}
		return null;
		};
		export const getCliPathChoco = () => {
		const chocoPath = `${process.env.ChocolateyInstall \|\| "C:\\ProgramData\\chocolatey"}\\bin\\aptos.exe`;
		if (existsSync(chocoPath)) {
		return chocoPath;
		}
		return null;
		};
		export const installViaWinget = () => {
		console.log("Installing Aptos CLI via winget...");
		execSync("winget install --id Aptos.Aptos --silent --accept-package-agreements --accept-source-agreements", {
		stdio: "inherit",
		});
		};
		export const installViaChoco = () => {
		console.log("Installing Aptos CLI via Chocolatey...");
		execSync("choco install aptos -y", { stdio: "inherit" });
		};
		export const updateViaWinget = () => {
		console.log("Updating Aptos CLI via winget...");
		execSync("winget upgrade --id Aptos.Aptos --silent --accept-package-agreements --accept-source-agreements", {
		stdio: "inherit",
		});
		};
		export const updateViaChoco = () => {
		console.log("Updating Aptos CLI via Chocolatey...");
		execSync("choco upgrade aptos -y", { stdio: "inherit" });
		};
		export const detectWindowsPackageManager = () => {
		if (isInstalledViaWinget()) {
		return "winget";
		}
		if (isInstalledViaChoco()) {
		return "choco";
		}
		return null;
		};
		//# sourceMappingURL=windowsPackageManagers.js.map

+1

dist/utils/windowsPackageManagers.js.map

+169

dist/utils/windowsPackageManagers.test.js

		import { execSync } from "node:child_process";
		import { existsSync } from "node:fs";
		import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
		vi.mock("child_process", () => ({
		execSync: vi.fn(),
		}));
		vi.mock("fs", () => ({
		existsSync: vi.fn(),
		}));
		vi.mock("./executableIsAvailable.js", () => ({
		executableIsAvailable: vi.fn(),
		}));
		import { executableIsAvailable } from "./executableIsAvailable.js";
		import { detectWindowsPackageManager, getCliPathChoco, getCliPathWinget, installViaChoco, installViaWinget, isChocoAvailable, isInstalledViaChoco, isInstalledViaWinget, isWingetAvailable, updateViaChoco, updateViaWinget, } from "./windowsPackageManagers.js";
		describe("windowsPackageManagers", () => {
		beforeEach(() => {
		vi.clearAllMocks();
		process.env.LOCALAPPDATA = "C:\\Users\\Test\\AppData\\Local";
		process.env.PROGRAMFILES = "C:\\Program Files";
		process.env.ChocolateyInstall = "C:\\ProgramData\\chocolatey";
		});
		afterEach(() => {
		vi.restoreAllMocks();
		});
		describe("isWingetAvailable", () => {
		it("should return true when winget is available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		expect(isWingetAvailable()).toBe(true);
		expect(executableIsAvailable).toHaveBeenCalledWith("winget");
		});
		it("should return false when winget is not available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(false);
		expect(isWingetAvailable()).toBe(false);
		});
		});
		describe("isChocoAvailable", () => {
		it("should return true when choco is available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		expect(isChocoAvailable()).toBe(true);
		expect(executableIsAvailable).toHaveBeenCalledWith("choco");
		});
		it("should return false when choco is not available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(false);
		expect(isChocoAvailable()).toBe(false);
		});
		});
		describe("isInstalledViaWinget", () => {
		it("should return true when aptos is installed via winget", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockReturnValue("Aptos.Aptos 1.0.0");
		expect(isInstalledViaWinget()).toBe(true);
		});
		it("should return false when winget is not available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(false);
		expect(isInstalledViaWinget()).toBe(false);
		});
		it("should return false when aptos is not in winget list", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockReturnValue("No packages found");
		expect(isInstalledViaWinget()).toBe(false);
		});
		it("should return false when winget list throws", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockImplementation(() => {
		throw new Error("winget error");
		});
		expect(isInstalledViaWinget()).toBe(false);
		});
		});
		describe("isInstalledViaChoco", () => {
		it("should return true when aptos is installed via choco", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockReturnValue("aptos 1.0.0");
		expect(isInstalledViaChoco()).toBe(true);
		});
		it("should return false when choco is not available", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(false);
		expect(isInstalledViaChoco()).toBe(false);
		});
		it("should return false when aptos is not in choco list", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(true);
		vi.mocked(execSync).mockReturnValue("0 packages installed");
		expect(isInstalledViaChoco()).toBe(false);
		});
		});
		describe("getCliPathWinget", () => {
		it("should return path when found via where command", () => {
		vi.mocked(existsSync).mockImplementation((path) => {
		return path === "C:\\found\\aptos.exe";
		});
		vi.mocked(execSync).mockReturnValue("C:\\found\\aptos.exe\n");
		expect(getCliPathWinget()).toBe("C:\\found\\aptos.exe");
		});
		it("should return null when not found", () => {
		vi.mocked(existsSync).mockReturnValue(false);
		vi.mocked(execSync).mockImplementation(() => {
		throw new Error("not found");
		});
		expect(getCliPathWinget()).toBeNull();
		});
		});
		describe("getCliPathChoco", () => {
		it("should return path when exists", () => {
		vi.mocked(existsSync).mockReturnValue(true);
		expect(getCliPathChoco()).toBe("C:\\ProgramData\\chocolatey\\bin\\aptos.exe");
		});
		it("should return null when not found", () => {
		vi.mocked(existsSync).mockReturnValue(false);
		expect(getCliPathChoco()).toBeNull();
		});
		});
		describe("installViaWinget", () => {
		it("should call winget install", () => {
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		installViaWinget();
		expect(execSync).toHaveBeenCalledWith("winget install --id Aptos.Aptos --silent --accept-package-agreements --accept-source-agreements", { stdio: "inherit" });
		});
		});
		describe("installViaChoco", () => {
		it("should call choco install", () => {
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		installViaChoco();
		expect(execSync).toHaveBeenCalledWith("choco install aptos -y", {
		stdio: "inherit",
		});
		});
		});
		describe("updateViaWinget", () => {
		it("should call winget upgrade", () => {
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		updateViaWinget();
		expect(execSync).toHaveBeenCalledWith("winget upgrade --id Aptos.Aptos --silent --accept-package-agreements --accept-source-agreements", { stdio: "inherit" });
		});
		});
		describe("updateViaChoco", () => {
		it("should call choco upgrade", () => {
		vi.mocked(execSync).mockReturnValue(Buffer.from(""));
		updateViaChoco();
		expect(execSync).toHaveBeenCalledWith("choco upgrade aptos -y", {
		stdio: "inherit",
		});
		});
		});
		describe("detectWindowsPackageManager", () => {
		it("should return winget when installed via winget", () => {
		vi.mocked(executableIsAvailable).mockImplementation((name) => {
		return name === "winget";
		});
		vi.mocked(execSync).mockReturnValue("Aptos.Aptos 1.0.0");
		expect(detectWindowsPackageManager()).toBe("winget");
		});
		it("should return choco when installed via choco", () => {
		vi.mocked(executableIsAvailable).mockImplementation((name) => {
		if (name === "winget")
		return false;
		if (name === "choco")
		return true;
		return false;
		});
		vi.mocked(execSync).mockReturnValue("aptos 1.0.0");
		expect(detectWindowsPackageManager()).toBe("choco");
		});
		it("should return null when not installed via package manager", () => {
		vi.mocked(executableIsAvailable).mockReturnValue(false);
		expect(detectWindowsPackageManager()).toBeNull();
		});
		});
		});
		//# sourceMappingURL=windowsPackageManagers.test.js.map

+1

dist/utils/windowsPackageManagers.test.js.map

+7

-2

dist/aptos.js

		#!/usr/bin/env node
		import { program } from "commander";
		import { runCLI } from "./tasks/run.js";
		import { parseCommandOptions } from "./utils/parseCommandOptions.js";
		import { runCLI } from "./tasks/run.js";
		program
		@@ -11,3 +11,5 @@ .name("aptos")
		.option("-b, --binary-path <path>", "path to an existing Aptos CLI binary")
		.allowUnknownOption();
		.option("-d, --direct-download", "skip package managers and download directly from GitHub")
		.allowUnknownOption()
		.allowExcessArguments(true);
		program.parse(process.argv);
		@@ -19,2 +21,5 @@ const main = async () => {
		binaryPath: program.opts().binaryPath,
		directDownload: program.opts().directDownload \|\|
		process.env.APTOS_DIRECT_DOWNLOAD === "1" \|\|
		process.env.APTOS_DIRECT_DOWNLOAD === "true",
		};
		@@ -21,0 +26,0 @@ const unknownOptions = program.args;

+1

-1

dist/aptos.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"aptos.js","sourceRoot":"","sources":["../bin/aptos.ts"],"names":[],"mappings":";AAWA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAExC,OAAO;KACJ,IAAI,CAAC,OAAO,CAAC;KACb,UAAU,CAAC,KAAK,CAAC;KACjB,MAAM,CAAC,eAAe,EAAE,uCAAuC,CAAC;KAChE,MAAM,CAAC,cAAc,EAAE,sCAAsC,CAAC;KAC9D,MAAM,CAAC,0BAA0B,EAAE,sCAAsC,CAAC;KAC1E,kBAAkB,EAAE,CAAC;AAExB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAE5B,MAAM,IAAI,GAAG,KAAK,IAAI,EAAE;IACtB,MAAM,OAAO,GAAG;QACd,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,OAAO;QAC/B,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM;QAC7B,UAAU,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,UAAU;KACtC,CAAC;IACF,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAGpC,IAAI,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAEpC,OAAO,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,mBAAmB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;AACrD,CAAC,CAAC;AAEF,IAAI,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC"}
		{"version":3,"file":"aptos.js","sourceRoot":"","sources":["../bin/aptos.ts"],"names":[],"mappings":";AAkBA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAErE,OAAO;KACJ,IAAI,CAAC,OAAO,CAAC;KACb,UAAU,CAAC,KAAK,CAAC;KACjB,MAAM,CAAC,eAAe,EAAE,uCAAuC,CAAC;KAChE,MAAM,CAAC,cAAc,EAAE,sCAAsC,CAAC;KAC9D,MAAM,CAAC,0BAA0B,EAAE,sCAAsC,CAAC;KAC1E,MAAM,CACL,uBAAuB,EACvB,yDAAyD,CAC1D;KACA,kBAAkB,EAAE;KACpB,oBAAoB,CAAC,IAAI,CAAC,CAAC;AAE9B,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAE5B,MAAM,IAAI,GAAG,KAAK,IAAI,EAAE;IACtB,MAAM,OAAO,GAAG;QACd,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,OAAO;QAC/B,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM;QAC7B,UAAU,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,UAAU;QACrC,cAAc,EACZ,OAAO,CAAC,IAAI,EAAE,CAAC,cAAc;YAC7B,OAAO,CAAC,GAAG,CAAC,qBAAqB,KAAK,GAAG;YACzC,OAAO,CAAC,GAAG,CAAC,qBAAqB,KAAK,MAAM;KAC/C,CAAC;IACF,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAGpC,IAAI,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAEpC,OAAO,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,mBAAmB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;AACrD,CAAC,CAAC;AAEF,IAAI,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC","sourcesContent":["#!/usr/bin/env node\n\n// Installation priorities by platform:\n//\n// macOS:\n// 1. Homebrew (if available) - builds for native CPU architecture\n// 2. Direct download from GitHub releases\n//\n// Windows:\n// 1. winget (if available)\n// 2. Chocolatey (if available)\n// 3. Direct download from GitHub releases\n//\n// Linux:\n// - Direct download from GitHub releases (with Ubuntu version detection)\n//\n// Use --direct-download or set APTOS_DIRECT_DOWNLOAD=1 to skip package managers.\n\nimport { program } from \"commander\";\nimport { runCLI } from \"./tasks/run.js\";\nimport { parseCommandOptions } from \"./utils/parseCommandOptions.js\";\n\nprogram\n .name(\"aptos\")\n .helpOption(false)\n .option(\"-i, --install\", \"install the latest version of the CLI\")\n .option(\"-u, --update\", \"update the CLI to the latest version\")\n .option(\"-b, --binary-path <path>\", \"path to an existing Aptos CLI binary\")\n .option(\n \"-d, --direct-download\",\n \"skip package managers and download directly from GitHub\",\n )\n .allowUnknownOption()\n .allowExcessArguments(true);\n\nprogram.parse(process.argv);\n\nconst main = async () => {\n const options = {\n install: program.opts().install,\n update: program.opts().update,\n binaryPath: program.opts().binaryPath,\n directDownload:\n program.opts().directDownload \|\|\n process.env.APTOS_DIRECT_DOWNLOAD === \"1\" \|\|\n process.env.APTOS_DIRECT_DOWNLOAD === \"true\",\n };\n const unknownOptions = program.args;\n\n // Manually check for `--help` and handle the CLI `--help`\n if (process.argv.includes(\"--help\")) {\n // Forward to the CLI\n return runCLI(unknownOptions, options.binaryPath);\n }\n\n await parseCommandOptions(options, unknownOptions);\n};\n\nmain().catch(console.error);\n"]}

+82

-31

dist/tasks/install.js

		@@ -1,42 +0,93 @@
		import { execSync } from "child_process";
		import { existsSync } from "fs";
		import { execSync } from "node:child_process";
		import { chmodSync, existsSync, mkdirSync } from "node:fs";
		import { tmpdir } from "node:os";
		import { join } from "node:path";
		import { installViaBrew, isBrewAvailable, isInstalledViaBrew, } from "../utils/brewOperations.js";
		import { GH_CLI_DOWNLOAD_URL, PNAME } from "../utils/consts.js";
		import { execSyncShell } from "../utils/execSyncShell.js";
		import { getCurrentOpenSSLVersion } from "../utils/versions.js";
		import { getOS } from "../utils/getUserOs.js";
		import { getLocalBinPath } from "../utils/getLocalBinPath.js";
		import { getLatestVersionGh } from "../utils/ghOperations.js";
		export const installCli = async () => {
		const path = getLocalBinPath();
		if (existsSync(path)) {
		import { getBinDir, getLocalBinPath, invalidateBinPathCache, } from "../utils/getLocalBinPath.js";
		import { getOS, getTargetPlatform } from "../utils/getUserOs.js";
		import { getCliVersion, hasUserSpecifiedVersion, } from "../utils/ghOperations.js";
		import { installViaChoco, installViaWinget, isChocoAvailable, isInstalledViaChoco, isInstalledViaWinget, isWingetAvailable, } from "../utils/windowsPackageManagers.js";
		export const installCli = async (directDownload = false) => {
		invalidateBinPathCache();
		const os = getOS();
		const useDirectDownload = directDownload \|\| hasUserSpecifiedVersion();
		if (useDirectDownload && hasUserSpecifiedVersion()) {
		console.log(`Using specified version from APTOS_CLI_VERSION: ${process.env.APTOS_CLI_VERSION}`);
		}
		if (!useDirectDownload) {
		if (os === "MacOS" && isBrewAvailable()) {
		if (isInstalledViaBrew()) {
		console.log("Aptos CLI is already installed via Homebrew");
		return;
		}
		installViaBrew();
		return;
		}
		if (os === "Windows") {
		if (isWingetAvailable()) {
		if (isInstalledViaWinget()) {
		console.log("Aptos CLI is already installed via winget");
		return;
		}
		installViaWinget();
		return;
		}
		if (isChocoAvailable()) {
		if (isInstalledViaChoco()) {
		console.log("Aptos CLI is already installed via Chocolatey");
		return;
		}
		installViaChoco();
		return;
		}
		}
		}
		const binaryPath = getLocalBinPath();
		if (existsSync(binaryPath)) {
		console.log("Aptos CLI is already installed");
		return;
		}
		const latestCLIVersion = await getLatestVersionGh();
		console.log(`Downloading aptos CLI version ${latestCLIVersion}`);
		const os = getOS();
		if (os === "Windows") {
		const url = `${GH_CLI_DOWNLOAD_URL}/${PNAME}-v${latestCLIVersion}/${PNAME}-${latestCLIVersion}-${os}-x86_64.zip`;
		execSync(`powershell -Command "if (!(Test-Path -Path 'C:\\tmp')) { New-Item -ItemType Directory -Path 'C:\\tmp' } ; Invoke-RestMethod -Uri ${url} -OutFile C:\\tmp\\aptos.zip; Expand-Archive -Path C:\\tmp\\aptos.zip -DestinationPath C:\\tmp -Force; Move-Item -Path C:\\tmp\\aptos.exe -Destination \"${path}\""`);
		const binDir = getBinDir();
		if (!existsSync(binDir)) {
		mkdirSync(binDir, { recursive: true });
		}
		else if (os === "MacOS") {
		execSyncShell("brew install aptos", { encoding: "utf8" });
		}
		else {
		let osVersion = "x86_64";
		let opensSslVersion = "1.0.0";
		try {
		opensSslVersion = getCurrentOpenSSLVersion();
		const targetPlatform = getTargetPlatform();
		const version = await getCliVersion(targetPlatform);
		console.log(`Downloading Aptos CLI version ${version} for ${targetPlatform}...`);
		const url = `${GH_CLI_DOWNLOAD_URL}/${PNAME}-v${version}/${PNAME}-${version}-${targetPlatform}.zip`;
		const tempDir = tmpdir();
		try {
		if (os === "Windows") {
		const zipPath = join(tempDir, "aptos-cli.zip");
		execSync(`powershell -Command "` +
		`Invoke-WebRequest -Uri '${url}' -OutFile '${zipPath}'; ` +
		`Expand-Archive -Path '${zipPath}' -DestinationPath '${binDir}' -Force; ` +
		`Remove-Item -Path '${zipPath}' -Force"`, { stdio: "inherit" });
		}
		catch (error) {
		console.log("Could not determine OpenSSL version, assuming older version (1.x.x)");
		else {
		const zipPath = join(tempDir, "aptos-cli.zip");
		execSync(`curl -L -o "${zipPath}" "${url}"`, { stdio: "inherit" });
		execSync(`unzip -o -q "${zipPath}" -d "${tempDir}"`, {
		stdio: "inherit",
		});
		const extractedBinary = join(tempDir, "aptos");
		execSync(`mv "${extractedBinary}" "${binaryPath}"`, { stdio: "inherit" });
		chmodSync(binaryPath, 0o755);
		try {
		execSync(`rm -f "${zipPath}"`, { stdio: "ignore" });
		}
		catch {
		}
		}
		if (opensSslVersion.startsWith("3.")) {
		osVersion = "22.04-x86_64";
		console.log(`Aptos CLI installed successfully to ${binaryPath}`);
		if (os !== "Windows") {
		console.log(`\nMake sure ${binDir} is in your PATH. You can add it by running:`);
		console.log(` export PATH="${binDir}:$PATH"`);
		}
		console.log(`Downloading CLI binary ${os}-${osVersion}`);
		const url = `${GH_CLI_DOWNLOAD_URL}/${PNAME}-v${latestCLIVersion}/${PNAME}-${latestCLIVersion}-${os}-${osVersion}.zip`;
		execSync(`curl -L -o /tmp/aptos.zip ${url}; unzip -o -q /tmp/aptos.zip -d /tmp; mv /tmp/aptos ${path};`);
		}
		catch (error) {
		throw new Error(`Failed to install Aptos CLI: ${error instanceof Error ? error.message : String(error)}`);
		}
		};
		//# sourceMappingURL=install.js.map

+1

-1

dist/tasks/install.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"install.js","sourceRoot":"","sources":["../../bin/tasks/install.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAEhC,OAAO,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG9D,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,IAAI,EAAE;IACnC,MAAM,IAAI,GAAG,eAAe,EAAE,CAAC;IAC/B,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,OAAO,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAC;QAC9C,OAAO;IACT,CAAC;IAED,MAAM,gBAAgB,GAAG,MAAM,kBAAkB,EAAE,CAAC;IACpD,OAAO,CAAC,GAAG,CAAC,iCAAiC,gBAAgB,EAAE,CAAC,CAAC;IACjE,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;IAEnB,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;QACrB,MAAM,GAAG,GAAG,GAAG,mBAAmB,IAAI,KAAK,KAAK,gBAAgB,IAAI,KAAK,IAAI,gBAAgB,IAAI,EAAE,aAAa,CAAC;QAEjH,QAAQ,CACN,oIAAoI,GAAG,4JAA4J,IAAI,KAAK,CAC7S,CAAC;IACJ,CAAC;SAAM,IAAI,EAAE,KAAK,OAAO,EAAE,CAAC;QAE1B,aAAa,CAAC,oBAAoB,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IAC5D,CAAC;SAAM,CAAC;QAGN,IAAI,SAAS,GAAG,QAAQ,CAAC;QACzB,IAAI,eAAe,GAAG,OAAO,CAAC;QAC9B,IAAI,CAAC;YACH,eAAe,GAAG,wBAAwB,EAAE,CAAC;QAC/C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CACT,qEAAqE,CACtE,CAAC;QACJ,CAAC;QAED,IAAI,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACrC,SAAS,GAAG,cAAc,CAAC;QAC7B,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,0BAA0B,EAAE,IAAI,SAAS,EAAE,CAAC,CAAC;QACzD,MAAM,GAAG,GAAG,GAAG,mBAAmB,IAAI,KAAK,KAAK,gBAAgB,IAAI,KAAK,IAAI,gBAAgB,IAAI,EAAE,IAAI,SAAS,MAAM,CAAC;QAEvH,QAAQ,CACN,6BAA6B,GAAG,uDAAuD,IAAI,GAAG,CAC/F,CAAC;IACJ,CAAC;AACH,CAAC,CAAC"}
		{"version":3,"file":"install.js","sourceRoot":"","sources":["../../bin/tasks/install.ts"],"names":[],"mappings":"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","sourcesContent":["import { execSync } from \"node:child_process\";\nimport { chmodSync, existsSync, mkdirSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport {\n installViaBrew,\n isBrewAvailable,\n isInstalledViaBrew,\n} from \"../utils/brewOperations.js\";\nimport { GH_CLI_DOWNLOAD_URL, PNAME } from \"../utils/consts.js\";\nimport {\n getBinDir,\n getLocalBinPath,\n invalidateBinPathCache,\n} from \"../utils/getLocalBinPath.js\";\nimport { getOS, getTargetPlatform } from \"../utils/getUserOs.js\";\nimport {\n getCliVersion,\n hasUserSpecifiedVersion,\n} from \"../utils/ghOperations.js\";\nimport {\n installViaChoco,\n installViaWinget,\n isChocoAvailable,\n isInstalledViaChoco,\n isInstalledViaWinget,\n isWingetAvailable,\n} from \"../utils/windowsPackageManagers.js\";\n\n/*\n Install the Aptos CLI.\n \n Installation priority:\n \n macOS:\n * 1. Homebrew (if available)\n * 2. Direct download from GitHub releases\n \n Windows:\n * 1. winget (if available)\n * 2. Chocolatey (if available)\n * 3. Direct download from GitHub releases\n \n Linux:\n * - Direct download from GitHub releases\n \n Note: When APTOS_CLI_VERSION is set, package managers are skipped and the\n * specified version is downloaded directly from GitHub releases.\n \n @param directDownload - If true, skip package managers and download directly\n */\nexport const installCli = async (\n directDownload: boolean = false,\n): Promise<void> => {\n invalidateBinPathCache();\n const os = getOS();\n\n // If a specific version is requested, force direct download\n // Package managers don't support installing specific versions\n const useDirectDownload = directDownload \|\| hasUserSpecifiedVersion();\n\n if (useDirectDownload && hasUserSpecifiedVersion()) {\n console.log(\n `Using specified version from APTOS_CLI_VERSION: ${process.env.APTOS_CLI_VERSION}`,\n );\n }\n\n // Skip package managers if directDownload is set or specific version requested\n if (!useDirectDownload) {\n // On macOS, prefer Homebrew if available\n if (os === \"MacOS\" && isBrewAvailable()) {\n if (isInstalledViaBrew()) {\n console.log(\"Aptos CLI is already installed via Homebrew\");\n return;\n }\n installViaBrew();\n return;\n }\n\n // On Windows, prefer winget, then Chocolatey\n if (os === \"Windows\") {\n if (isWingetAvailable()) {\n if (isInstalledViaWinget()) {\n console.log(\"Aptos CLI is already installed via winget\");\n return;\n }\n installViaWinget();\n return;\n }\n\n if (isChocoAvailable()) {\n if (isInstalledViaChoco()) {\n console.log(\"Aptos CLI is already installed via Chocolatey\");\n return;\n }\n installViaChoco();\n return;\n }\n }\n }\n\n // Direct download installation\n const binaryPath = getLocalBinPath();\n if (existsSync(binaryPath)) {\n console.log(\"Aptos CLI is already installed\");\n return;\n }\n\n // Ensure the bin directory exists\n const binDir = getBinDir();\n if (!existsSync(binDir)) {\n mkdirSync(binDir, { recursive: true });\n }\n\n // Get target platform first for version validation\n const targetPlatform = getTargetPlatform();\n\n // Get the version to install (user-specified or latest)\n const version = await getCliVersion(targetPlatform);\n\n console.log(\n `Downloading Aptos CLI version ${version} for ${targetPlatform}...`,\n );\n\n // Build download URL matching official release artifact naming\n const url = `${GH_CLI_DOWNLOAD_URL}/${PNAME}-v${version}/${PNAME}-${version}-${targetPlatform}.zip`;\n\n const tempDir = tmpdir();\n\n try {\n if (os === \"Windows\") {\n // Windows installation using PowerShell\n const zipPath = join(tempDir, \"aptos-cli.zip\");\n execSync(\n `powershell -Command \"` +\n `Invoke-WebRequest -Uri '${url}' -OutFile '${zipPath}'; ` +\n `Expand-Archive -Path '${zipPath}' -DestinationPath '${binDir}' -Force; ` +\n `Remove-Item -Path '${zipPath}' -Force\"`,\n { stdio: \"inherit\" },\n );\n } else {\n // macOS (without Homebrew) and Linux installation using curl/unzip\n const zipPath = join(tempDir, \"aptos-cli.zip\");\n\n // Download\n execSync(`curl -L -o \"${zipPath}\" \"${url}\"`, { stdio: \"inherit\" });\n\n // Extract\n execSync(`unzip -o -q \"${zipPath}\" -d \"${tempDir}\"`, {\n stdio: \"inherit\",\n });\n\n // Move binary to bin directory\n const extractedBinary = join(tempDir, \"aptos\");\n execSync(`mv \"${extractedBinary}\" \"${binaryPath}\"`, { stdio: \"inherit\" });\n\n // Set executable permissions\n chmodSync(binaryPath, 0o755);\n\n // Clean up\n try {\n execSync(`rm -f \"${zipPath}\"`, { stdio: \"ignore\" });\n } catch {\n // Ignore cleanup errors\n }\n }\n\n console.log(`Aptos CLI installed successfully to ${binaryPath}`);\n\n // Remind user about PATH if needed\n if (os !== \"Windows\") {\n console.log(\n `\\nMake sure ${binDir} is in your PATH. You can add it by running:`,\n );\n console.log(` export PATH=\"${binDir}:$PATH\"`);\n }\n } catch (error) {\n throw new Error(\n `Failed to install Aptos CLI: ${error instanceof Error ? error.message : String(error)}`,\n );\n }\n};\n"]}

+13

-8

dist/tasks/run.js

		@@ -1,8 +0,8 @@
		import { spawn } from "child_process";
		import { existsSync } from "fs";
		import { getOS } from "../utils/getUserOs.js";
		import { spawn } from "node:child_process";
		import { existsSync } from "node:fs";
		import { getLocalBinPath } from "../utils/getLocalBinPath.js";
		import { getPlatformInfo } from "../utils/getUserOs.js";
		export const runCLI = async (args = [], binaryPath) => {
		const path = binaryPath \|\| getLocalBinPath();
		if (!existsSync(path)) {
		const cliPath = binaryPath \|\| getLocalBinPath();
		if (!existsSync(cliPath)) {
		if (binaryPath) {
		@@ -15,8 +15,13 @@ console.error(`Error: Binary not found at specified path: ${binaryPath}`);
		}
		const os = getOS();
		spawn(path, args, {
		const { os } = getPlatformInfo();
		const child = spawn(cliPath, args, {
		stdio: "inherit",
		shell: os === "Windows",
		shell: os === "windows",
		});
		child.on("exit", (code) => {
		if (code !== null && code !== 0) {
		process.exit(code);
		}
		});
		};
		//# sourceMappingURL=run.js.map

+1

-1

dist/tasks/run.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"run.js","sourceRoot":"","sources":["../../bin/tasks/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE9D,MAAM,CAAC,MAAM,MAAM,GAAG,KAAK,EAAE,OAAiB,EAAE,EAAE,UAAmB,EAAE,EAAE;IACvE,MAAM,IAAI,GAAG,UAAU,IAAI,eAAe,EAAE,CAAC;IAC7C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,IAAI,UAAU,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,8CAA8C,UAAU,EAAE,CAAC,CAAC;YAC1E,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;QACD,OAAO,CAAC,GAAG,CACT,+DAA+D,CAChE,CAAC;QACF,OAAO;IACT,CAAC;IACD,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;IAInB,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE;QAChB,KAAK,EAAE,SAAS;QAChB,KAAK,EAAE,EAAE,KAAK,SAAS;KACxB,CAAC,CAAC;AACL,CAAC,CAAC"}
		{"version":3,"file":"run.js","sourceRoot":"","sources":["../../bin/tasks/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAOxD,MAAM,CAAC,MAAM,MAAM,GAAG,KAAK,EACzB,OAAiB,EAAE,EACnB,UAAmB,EACJ,EAAE;IACjB,MAAM,OAAO,GAAG,UAAU,IAAI,eAAe,EAAE,CAAC;IAEhD,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QACzB,IAAI,UAAU,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,8CAA8C,UAAU,EAAE,CAAC,CAAC;YAC1E,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;QACD,OAAO,CAAC,GAAG,CACT,+DAA+D,CAChE,CAAC;QACF,OAAO;IACT,CAAC;IAED,MAAM,EAAE,EAAE,EAAE,GAAG,eAAe,EAAE,CAAC;IAGjC,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE;QACjC,KAAK,EAAE,SAAS;QAChB,KAAK,EAAE,EAAE,KAAK,SAAS;KACxB,CAAC,CAAC;IAGH,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;QACxB,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC","sourcesContent":["import { spawn } from \"node:child_process\";\nimport { existsSync } from \"node:fs\";\nimport { getLocalBinPath } from \"../utils/getLocalBinPath.js\";\nimport { getPlatformInfo } from \"../utils/getUserOs.js\";\n\n/*\n Run the Aptos CLI with the provided arguments.\n * @param args - Arguments to pass to the CLI\n * @param binaryPath - Optional path to a custom binary\n */\nexport const runCLI = async (\n args: string[] = [],\n binaryPath?: string,\n): Promise<void> => {\n const cliPath = binaryPath \|\| getLocalBinPath();\n\n if (!existsSync(cliPath)) {\n if (binaryPath) {\n console.error(`Error: Binary not found at specified path: ${binaryPath}`);\n process.exit(1);\n }\n console.log(\n \"Aptos CLI not installed, run `npx aptos --install` to install\",\n );\n return;\n }\n\n const { os } = getPlatformInfo();\n\n // Spawn a child process to run the real CLI executable with the forwarded arguments\n const child = spawn(cliPath, args, {\n stdio: \"inherit\", // Forward the stdio so output is visible\n shell: os === \"windows\", // Use shell on Windows for proper path handling\n });\n\n // Forward the exit code from the child process to the parent\n child.on(\"exit\", (code) => {\n if (code !== null && code !== 0) {\n process.exit(code);\n }\n });\n};\n"]}

+55

-20

dist/tasks/update.js

		@@ -1,33 +0,68 @@
		import { existsSync } from "fs";
		import { getLocalBinPath } from "../utils/getLocalBinPath.js";
		import { execSync } from "child_process";
		import { getOS } from "../utils/getUserOs.js";
		import { getLatestVersionGh } from "../utils/ghOperations.js";
		import { existsSync, unlinkSync } from "node:fs";
		import { isInstalledViaBrew, updateViaBrew } from "../utils/brewOperations.js";
		import { execSyncShell } from "../utils/execSyncShell.js";
		import { getLocalBinPath, invalidateBinPathCache, } from "../utils/getLocalBinPath.js";
		import { getTargetPlatform } from "../utils/getUserOs.js";
		import { getCliVersion, hasUserSpecifiedVersion, } from "../utils/ghOperations.js";
		import { isInstalledViaChoco, isInstalledViaWinget, updateViaChoco, updateViaWinget, } from "../utils/windowsPackageManagers.js";
		import { installCli } from "./install.js";
		export const updateCli = async () => {
		const path = getLocalBinPath();
		if (!existsSync(path)) {
		export const updateCli = async (directDownload = false) => {
		invalidateBinPathCache();
		const binaryPath = getLocalBinPath();
		if (!existsSync(binaryPath)) {
		console.log("Aptos CLI not installed, run `npx aptos --install` to install");
		return;
		}
		if (getOS() === "MacOS") {
		return execSync("brew upgrade aptos");
		const useDirectDownload = directDownload \|\| hasUserSpecifiedVersion();
		if (useDirectDownload && hasUserSpecifiedVersion()) {
		console.log(`Using specified version from APTOS_CLI_VERSION: ${process.env.APTOS_CLI_VERSION}`);
		}
		else {
		const latestVersion = await getLatestVersionGh();
		const currentVersion = execSyncShell(`${path} --version`, {
		if (!useDirectDownload) {
		if (isInstalledViaBrew()) {
		updateViaBrew();
		return;
		}
		if (isInstalledViaWinget()) {
		updateViaWinget();
		return;
		}
		if (isInstalledViaChoco()) {
		updateViaChoco();
		return;
		}
		}
		const targetPlatform = getTargetPlatform();
		const targetVersion = await getCliVersion(targetPlatform);
		let currentVersion;
		try {
		const versionOutput = String(execSyncShell(`"${binaryPath}" --version`, {
		encoding: "utf8",
		})
		.trim()
		.split(" ")[1];
		if (currentVersion !== latestVersion) {
		console.log(`A newer version of the CLI is available: ${latestVersion}, installing...`);
		await installCli();
		})).trim();
		currentVersion = versionOutput.split(" ")[1] \|\| "";
		}
		catch {
		console.error("Warning: Could not determine current CLI version");
		currentVersion = "";
		}
		if (currentVersion === targetVersion) {
		if (hasUserSpecifiedVersion()) {
		console.log(`CLI is already at the specified version (${currentVersion})`);
		}
		else {
		console.log(`CLI is up to date`);
		console.log(`CLI is up to date (version ${currentVersion})`);
		}
		return;
		}
		const updateDescription = hasUserSpecifiedVersion()
		? `Switching CLI from version ${currentVersion \|\| "unknown"} to ${targetVersion}...`
		: `Updating CLI from version ${currentVersion \|\| "unknown"} to ${targetVersion}...`;
		console.log(updateDescription);
		try {
		unlinkSync(binaryPath);
		}
		catch {
		console.error(`Warning: Could not remove old binary at ${binaryPath}`);
		}
		await installCli(useDirectDownload);
		};
		//# sourceMappingURL=update.js.map

+1

-1

dist/tasks/update.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"update.js","sourceRoot":"","sources":["../../bin/tasks/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAEhC,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,MAAM,CAAC,MAAM,SAAS,GAAG,KAAK,IAAI,EAAE;IAClC,MAAM,IAAI,GAAG,eAAe,EAAE,CAAC;IAE/B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,OAAO,CAAC,GAAG,CACT,+DAA+D,CAChE,CAAC;QACF,OAAO;IACT,CAAC;IAED,IAAI,KAAK,EAAE,KAAK,OAAO,EAAE,CAAC;QAExB,OAAO,QAAQ,CAAC,oBAAoB,CAAC,CAAC;IACxC,CAAC;SAAM,CAAC;QACN,MAAM,aAAa,GAAG,MAAM,kBAAkB,EAAE,CAAC;QAEjD,MAAM,cAAc,GAAG,aAAa,CAAC,GAAG,IAAI,YAAY,EAAE;YACxD,QAAQ,EAAE,MAAM;SACjB,CAAC;aACC,IAAI,EAAE;aACN,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAEjB,IAAI,cAAc,KAAK,aAAa,EAAE,CAAC;YACrC,OAAO,CAAC,GAAG,CACT,4CAA4C,aAAa,iBAAiB,CAC3E,CAAC;YACF,MAAM,UAAU,EAAE,CAAC;QACrB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;AACH,CAAC,CAAC"}
		{"version":3,"file":"update.js","sourceRoot":"","sources":["../../bin/tasks/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EACL,eAAe,EACf,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EACL,aAAa,EACb,uBAAuB,GACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,eAAe,GAChB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAgB1C,MAAM,CAAC,MAAM,SAAS,GAAG,KAAK,EAC5B,iBAA0B,KAAK,EAChB,EAAE;IACjB,sBAAsB,EAAE,CAAC;IACzB,MAAM,UAAU,GAAG,eAAe,EAAE,CAAC;IAErC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QAC5B,OAAO,CAAC,GAAG,CACT,+DAA+D,CAChE,CAAC;QACF,OAAO;IACT,CAAC;IAGD,MAAM,iBAAiB,GAAG,cAAc,IAAI,uBAAuB,EAAE,CAAC;IAEtE,IAAI,iBAAiB,IAAI,uBAAuB,EAAE,EAAE,CAAC;QACnD,OAAO,CAAC,GAAG,CACT,mDAAmD,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,CACnF,CAAC;IACJ,CAAC;IAGD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEvB,IAAI,kBAAkB,EAAE,EAAE,CAAC;YACzB,aAAa,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QAGD,IAAI,oBAAoB,EAAE,EAAE,CAAC;YAC3B,eAAe,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QAGD,IAAI,mBAAmB,EAAE,EAAE,CAAC;YAC1B,cAAc,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;IACH,CAAC;IAGD,MAAM,cAAc,GAAG,iBAAiB,EAAE,CAAC;IAG3C,MAAM,aAAa,GAAG,MAAM,aAAa,CAAC,cAAc,CAAC,CAAC;IAG1D,IAAI,cAAsB,CAAC;IAC3B,IAAI,CAAC;QACH,MAAM,aAAa,GAAG,MAAM,CAC1B,aAAa,CAAC,IAAI,UAAU,aAAa,EAAE;YACzC,QAAQ,EAAE,MAAM;SACjB,CAAC,CACH,CAAC,IAAI,EAAE,CAAC;QAET,cAAc,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACrD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAAC;QAClE,cAAc,GAAG,EAAE,CAAC;IACtB,CAAC;IAGD,IAAI,cAAc,KAAK,aAAa,EAAE,CAAC;QACrC,IAAI,uBAAuB,EAAE,EAAE,CAAC;YAC9B,OAAO,CAAC,GAAG,CACT,4CAA4C,cAAc,GAAG,CAC9D,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,8BAA8B,cAAc,GAAG,CAAC,CAAC;QAC/D,CAAC;QACD,OAAO;IACT,CAAC;IAED,MAAM,iBAAiB,GAAG,uBAAuB,EAAE;QACjD,CAAC,CAAC,8BAA8B,cAAc,IAAI,SAAS,OAAO,aAAa,KAAK;QACpF,CAAC,CAAC,6BAA6B,cAAc,IAAI,SAAS,OAAO,aAAa,KAAK,CAAC;IAEtF,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAG/B,IAAI,CAAC;QACH,UAAU,CAAC,UAAU,CAAC,CAAC;IACzB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,KAAK,CAAC,2CAA2C,UAAU,EAAE,CAAC,CAAC;IACzE,CAAC;IAED,MAAM,UAAU,CAAC,iBAAiB,CAAC,CAAC;AACtC,CAAC,CAAC","sourcesContent":["import { existsSync, unlinkSync } from \"node:fs\";\nimport { isInstalledViaBrew, updateViaBrew } from \"../utils/brewOperations.js\";\nimport { execSyncShell } from \"../utils/execSyncShell.js\";\nimport {\n getLocalBinPath,\n invalidateBinPathCache,\n} from \"../utils/getLocalBinPath.js\";\nimport { getTargetPlatform } from \"../utils/getUserOs.js\";\nimport {\n getCliVersion,\n hasUserSpecifiedVersion,\n} from \"../utils/ghOperations.js\";\nimport {\n isInstalledViaChoco,\n isInstalledViaWinget,\n updateViaChoco,\n updateViaWinget,\n} from \"../utils/windowsPackageManagers.js\";\nimport { installCli } from \"./install.js\";\n\n/*\n Update the Aptos CLI to the latest version (or a specific version if APTOS_CLI_VERSION is set).\n \n Update methods by installation type:\n * - Homebrew: `brew upgrade aptos`\n * - winget: `winget upgrade`\n * - Chocolatey: `choco upgrade`\n * - Direct download: Compare versions and reinstall if newer/different\n \n Note: When APTOS_CLI_VERSION is set, package managers are skipped and the\n * specified version is downloaded directly from GitHub releases.\n \n @param directDownload - If true, skip package manager updates and force direct download\n */\nexport const updateCli = async (\n directDownload: boolean = false,\n): Promise<void> => {\n invalidateBinPathCache();\n const binaryPath = getLocalBinPath();\n\n if (!existsSync(binaryPath)) {\n console.log(\n \"Aptos CLI not installed, run `npx aptos --install` to install\",\n );\n return;\n }\n\n // If a specific version is requested, force direct download\n const useDirectDownload = directDownload \|\| hasUserSpecifiedVersion();\n\n if (useDirectDownload && hasUserSpecifiedVersion()) {\n console.log(\n `Using specified version from APTOS_CLI_VERSION: ${process.env.APTOS_CLI_VERSION}`,\n );\n }\n\n // Check for package manager installations (unless directDownload is set or specific version requested)\n if (!useDirectDownload) {\n // If installed via Homebrew, use brew upgrade\n if (isInstalledViaBrew()) {\n updateViaBrew();\n return;\n }\n\n // If installed via winget, use winget upgrade\n if (isInstalledViaWinget()) {\n updateViaWinget();\n return;\n }\n\n // If installed via Chocolatey, use choco upgrade\n if (isInstalledViaChoco()) {\n updateViaChoco();\n return;\n }\n }\n\n // Get target platform for version validation\n const targetPlatform = getTargetPlatform();\n\n // Get the target version (user-specified or latest)\n const targetVersion = await getCliVersion(targetPlatform);\n\n // Get the current version of the CLI\n let currentVersion: string;\n try {\n const versionOutput = String(\n execSyncShell(`\"${binaryPath}\" --version`, {\n encoding: \"utf8\",\n }),\n ).trim();\n // Version output format: \"aptos X.Y.Z\"\n currentVersion = versionOutput.split(\" \")[1] \|\| \"\";\n } catch {\n console.error(\"Warning: Could not determine current CLI version\");\n currentVersion = \"\";\n }\n\n // Check if the installed version matches the target version\n if (currentVersion === targetVersion) {\n if (hasUserSpecifiedVersion()) {\n console.log(\n `CLI is already at the specified version (${currentVersion})`,\n );\n } else {\n console.log(`CLI is up to date (version ${currentVersion})`);\n }\n return;\n }\n\n const updateDescription = hasUserSpecifiedVersion()\n ? `Switching CLI from version ${currentVersion \|\| \"unknown\"} to ${targetVersion}...`\n : `Updating CLI from version ${currentVersion \|\| \"unknown\"} to ${targetVersion}...`;\n\n console.log(updateDescription);\n\n // Remove the old binary before installing the new one\n try {\n unlinkSync(binaryPath);\n } catch {\n console.error(`Warning: Could not remove old binary at ${binaryPath}`);\n }\n\n await installCli(useDirectDownload);\n};\n"]}

+30

-4

dist/utils/brewOperations.js

		@@ -1,8 +0,34 @@
		import { execSyncShell } from "./execSyncShell.js";
		import { execSync } from "node:child_process";
		import { existsSync } from "node:fs";
		import { executableIsAvailable } from "./executableIsAvailable.js";
		export const isBrewAvailable = () => {
		return executableIsAvailable("brew");
		};
		export const isInstalledViaBrew = () => {
		if (!isBrewAvailable()) {
		return false;
		}
		try {
		const path = getCliPathBrew();
		return existsSync(path);
		}
		catch {
		return false;
		}
		};
		export const getCliPathBrew = () => {
		const directory = execSyncShell("brew --prefix aptos", { encoding: "utf8" })
		.toString()
		.trim();
		const directory = execSync("brew --prefix aptos", {
		encoding: "utf8",
		stdio: ["pipe", "pipe", "pipe"],
		}).trim();
		return `${directory}/bin/aptos`;
		};
		export const installViaBrew = () => {
		console.log("Installing Aptos CLI via Homebrew...");
		execSync("brew install aptos", { stdio: "inherit" });
		};
		export const updateViaBrew = () => {
		console.log("Updating Aptos CLI via Homebrew...");
		execSync("brew upgrade aptos", { stdio: "inherit" });
		};
		//# sourceMappingURL=brewOperations.js.map

+1

-1

dist/utils/brewOperations.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"brewOperations.js","sourceRoot":"","sources":["../../bin/utils/brewOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAMnD,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,EAAE;IACjC,MAAM,SAAS,GAAG,aAAa,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;SACzE,QAAQ,EAAE;SACV,IAAI,EAAE,CAAC;IACV,OAAO,GAAG,SAAS,YAAY,CAAC;AAClC,CAAC,CAAC"}
		{"version":3,"file":"brewOperations.js","sourceRoot":"","sources":["../../bin/utils/brewOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAKnE,MAAM,CAAC,MAAM,eAAe,GAAG,GAAY,EAAE;IAC3C,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC,CAAC;AAKF,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAY,EAAE;IAC9C,IAAI,CAAC,eAAe,EAAE,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,cAAc,EAAE,CAAC;QAC9B,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC;AAMF,MAAM,CAAC,MAAM,cAAc,GAAG,GAAW,EAAE;IACzC,MAAM,SAAS,GAAG,QAAQ,CAAC,qBAAqB,EAAE;QAChD,QAAQ,EAAE,MAAM;QAChB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;KAChC,CAAC,CAAC,IAAI,EAAE,CAAC;IACV,OAAO,GAAG,SAAS,YAAY,CAAC;AAClC,CAAC,CAAC;AAKF,MAAM,CAAC,MAAM,cAAc,GAAG,GAAS,EAAE;IACvC,OAAO,CAAC,GAAG,CAAC,sCAAsC,CAAC,CAAC;IACpD,QAAQ,CAAC,oBAAoB,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;AACvD,CAAC,CAAC;AAKF,MAAM,CAAC,MAAM,aAAa,GAAG,GAAS,EAAE;IACtC,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;IAClD,QAAQ,CAAC,oBAAoB,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;AACvD,CAAC,CAAC","sourcesContent":["import { execSync } from \"node:child_process\";\nimport { existsSync } from \"node:fs\";\nimport { executableIsAvailable } from \"./executableIsAvailable.js\";\n\n/*\n Check if Homebrew is available on the system.\n /\nexport const isBrewAvailable = (): boolean => {\n return executableIsAvailable(\"brew\");\n};\n\n/\n Check if the Aptos CLI was installed via Homebrew.\n /\nexport const isInstalledViaBrew = (): boolean => {\n if (!isBrewAvailable()) {\n return false;\n }\n try {\n const path = getCliPathBrew();\n return existsSync(path);\n } catch {\n return false;\n }\n};\n\n/\n Get the path to the Aptos CLI binary installed via Homebrew.\n * Based on the installation path of the aptos formula.\n /\nexport const getCliPathBrew = (): string => {\n const directory = execSync(\"brew --prefix aptos\", {\n encoding: \"utf8\",\n stdio: [\"pipe\", \"pipe\", \"pipe\"],\n }).trim();\n return `${directory}/bin/aptos`;\n};\n\n/\n Install the Aptos CLI via Homebrew.\n /\nexport const installViaBrew = (): void => {\n console.log(\"Installing Aptos CLI via Homebrew...\");\n execSync(\"brew install aptos\", { stdio: \"inherit\" });\n};\n\n/\n Update the Aptos CLI via Homebrew.\n */\nexport const updateViaBrew = (): void => {\n console.log(\"Updating Aptos CLI via Homebrew...\");\n execSync(\"brew upgrade aptos\", { stdio: \"inherit\" });\n};\n"]}

+1

-1

dist/utils/consts.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"consts.js","sourceRoot":"","sources":["../../bin/utils/consts.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,KAAK,GAAG,WAAW,CAAC;AACjC,MAAM,CAAC,MAAM,mBAAmB,GAC9B,4DAA4D,CAAC"}
		{"version":3,"file":"consts.js","sourceRoot":"","sources":["../../bin/utils/consts.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,KAAK,GAAG,WAAW,CAAC;AACjC,MAAM,CAAC,MAAM,mBAAmB,GAC9B,4DAA4D,CAAC","sourcesContent":["export const PNAME = \"aptos-cli\";\nexport const GH_CLI_DOWNLOAD_URL =\n \"https://github.com/aptos-labs/aptos-core/releases/download\";\n"]}

+6

-2

dist/utils/execSyncShell.js

		@@ -1,5 +0,9 @@
		import { execSync } from "child_process";
		import { execSync } from "node:child_process";
		export const execSyncShell = (command, options) => {
		return execSync(command, { shell: true, ...options });
		const execOptions = {
		...options,
		shell: true,
		};
		return execSync(command, execOptions);
		};
		//# sourceMappingURL=execSyncShell.js.map

+1

-1

dist/utils/execSyncShell.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"execSyncShell.js","sourceRoot":"","sources":["../../bin/utils/execSyncShell.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKzC,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;IAChD,OAAO,QAAQ,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;AACxD,CAAC,CAAC"}
		{"version":3,"file":"execSyncShell.js","sourceRoot":"","sources":["../../bin/utils/execSyncShell.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAQpE,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,OAAe,EACf,OAA8B,EACb,EAAE;IAGnB,MAAM,WAAW,GAAG;QAClB,GAAG,OAAO;QACV,KAAK,EAAE,IAAI;KACkB,CAAC;IAChC,OAAO,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;AACxC,CAAC,CAAC","sourcesContent":["import { type ExecSyncOptions, execSync } from \"node:child_process\";\n\ntype ExecSyncShellOptions = Omit<ExecSyncOptions, \"shell\">;\n\n/*\n Wrapper around execSync that uses the shell.\n * This always executes with shell: true for cross-platform compatibility.\n */\nexport const execSyncShell = (\n command: string,\n options?: ExecSyncShellOptions,\n): Buffer \| string => {\n // Type assertion needed due to @types/node ExecSyncOptions overload complexity\n // where shell is typed as string \| boolean but overloads expect specific types\n const execOptions = {\n ...options,\n shell: true,\n } as unknown as ExecSyncOptions;\n return execSync(command, execOptions);\n};\n"]}

+76

-20

dist/utils/getLocalBinPath.js

		@@ -1,30 +0,86 @@
		import { dirname } from "path";
		import { executableIsAvailable } from "./aptosExecutableIsAvailable.js";
		import { getCliPathBrew } from "./brewOperations.js";
		import { PNAME } from "./consts.js";
		import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
		import { homedir } from "node:os";
		import { dirname, join } from "node:path";
		import { getCliPathBrew, isInstalledViaBrew } from "./brewOperations.js";
		import { getOS } from "./getUserOs.js";
		import { fileURLToPath } from "url";
		import { getCliPathChoco, getCliPathWinget, isInstalledViaChoco, isInstalledViaWinget, } from "./windowsPackageManagers.js";
		const getCachePath = () => {
		if (getOS() === "Windows") {
		return join(homedir(), ".aptoscli", ".bin-path-cache");
		}
		return join(homedir(), ".local", "share", "aptos-cli", ".bin-path-cache");
		};
		const readCachedBinPath = () => {
		try {
		const cached = readFileSync(getCachePath(), "utf8").trim();
		if (cached && existsSync(cached)) {
		return cached;
		}
		}
		catch {
		}
		return undefined;
		};
		const writeCachedBinPath = (binPath) => {
		try {
		const cachePath = getCachePath();
		mkdirSync(dirname(cachePath), { recursive: true });
		writeFileSync(cachePath, binPath, "utf8");
		}
		catch {
		}
		};
		export const invalidateBinPathCache = () => {
		try {
		unlinkSync(getCachePath());
		}
		catch {
		}
		};
		export const getBinDir = () => {
		const os = getOS();
		if (os === "Windows") {
		return join(homedir(), ".aptoscli", "bin");
		}
		return join(homedir(), ".local", "bin");
		};
		export const getLocalBinPath = () => {
		let path;
		const cached = readCachedBinPath();
		if (cached) {
		return cached;
		}
		const os = getOS();
		if (os === "MacOS") {
		const brewInstalled = executableIsAvailable("brew");
		if (!brewInstalled) {
		throw "Please install brew to continue: https://brew.sh/";
		if (isInstalledViaBrew()) {
		try {
		const brewPath = getCliPathBrew();
		writeCachedBinPath(brewPath);
		return brewPath;
		}
		catch {
		}
		}
		try {
		path = getCliPathBrew();
		}
		if (os === "Windows") {
		if (isInstalledViaWinget()) {
		const wingetPath = getCliPathWinget();
		if (wingetPath) {
		writeCachedBinPath(wingetPath);
		return wingetPath;
		}
		}
		catch (e) {
		path = "";
		if (isInstalledViaChoco()) {
		const chocoPath = getCliPathChoco();
		if (chocoPath) {
		writeCachedBinPath(chocoPath);
		return chocoPath;
		}
		}
		}
		else if (os === "Windows") {
		path = `${dirname(fileURLToPath(import.meta.url))}\\${PNAME}.exe`;
		}
		else {
		path = `${dirname(fileURLToPath(import.meta.url))}/${PNAME}`;
		}
		return path;
		const binDir = getBinDir();
		const binaryName = os === "Windows" ? "aptos.exe" : "aptos";
		const defaultPath = join(binDir, binaryName);
		writeCachedBinPath(defaultPath);
		return defaultPath;
		};
		//# sourceMappingURL=getLocalBinPath.js.map

+1

-1

dist/utils/getLocalBinPath.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"getLocalBinPath.js","sourceRoot":"","sources":["../../bin/utils/getLocalBinPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AAEpC,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,EAAE;IAClC,IAAI,IAAI,CAAC;IACT,MAAM,EAAE,GAAG,KAAK,EAAE,CAAC;IACnB,IAAI,EAAE,KAAK,OAAO,EAAE,CAAC;QAEnB,MAAM,aAAa,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;QACpD,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,MAAM,mDAAmD,CAAC;QAC5D,CAAC;QACD,IAAI,CAAC;YACH,IAAI,GAAG,cAAc,EAAE,CAAC;QAC1B,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,IAAI,GAAG,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;SAAM,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;QAC5B,IAAI,GAAG,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC;IACpE,CAAC;SAAM,CAAC;QACN,IAAI,GAAG,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;IAC/D,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC"}
		{"version":3,"file":"getLocalBinPath.js","sourceRoot":"","sources":["../../bin/utils/getLocalBinPath.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n existsSync,\n mkdirSync,\n readFileSync,\n unlinkSync,\n writeFileSync,\n} from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\nimport { getCliPathBrew, isInstalledViaBrew } from \"./brewOperations.js\";\nimport { getOS } from \"./getUserOs.js\";\nimport {\n getCliPathChoco,\n getCliPathWinget,\n isInstalledViaChoco,\n isInstalledViaWinget,\n} from \"./windowsPackageManagers.js\";\n\n/*\n Path to the cached binary location file.\n * Avoids expensive shell spawns (brew --prefix, winget list) on every run.\n /\nconst getCachePath = (): string => {\n if (getOS() === \"Windows\") {\n return join(homedir(), \".aptoscli\", \".bin-path-cache\");\n }\n return join(homedir(), \".local\", \"share\", \"aptos-cli\", \".bin-path-cache\");\n};\n\nconst readCachedBinPath = (): string \| undefined => {\n try {\n const cached = readFileSync(getCachePath(), \"utf8\").trim();\n if (cached && existsSync(cached)) {\n return cached;\n }\n } catch {\n // No cache or unreadable\n }\n return undefined;\n};\n\nconst writeCachedBinPath = (binPath: string): void => {\n try {\n const cachePath = getCachePath();\n mkdirSync(dirname(cachePath), { recursive: true });\n writeFileSync(cachePath, binPath, \"utf8\");\n } catch {\n // Non-fatal — caching is best-effort\n }\n};\n\n/\n Invalidate the cached binary path.\n * Call this when install or update changes the binary location.\n /\nexport const invalidateBinPathCache = (): void => {\n try {\n unlinkSync(getCachePath());\n } catch {\n // No cache to invalidate\n }\n};\n\n/\n Get the binary directory path where the CLI should be installed.\n * Matches the official Aptos CLI install scripts:\n * - macOS/Linux: ~/.local/bin\n * - Windows: $USERPROFILE\\.aptoscli\\bin\n /\nexport const getBinDir = (): string => {\n const os = getOS();\n\n if (os === \"Windows\") {\n // Match official Windows script: $env:USERPROFILE\\.aptoscli\\bin\n return join(homedir(), \".aptoscli\", \"bin\");\n }\n\n // Match official Unix script: $HOME/.local/bin\n return join(homedir(), \".local\", \"bin\");\n};\n\n/\n Get the full path to the Aptos CLI binary.\n \n Uses a file-based cache to avoid expensive shell spawns (brew --prefix,\n * winget list) on every invocation. The cache is invalidated by install\n * and update tasks.\n \n Checks for package manager installations first:\n * - macOS: Homebrew\n * - Windows: winget, then Chocolatey\n \n Otherwise uses the standard paths:\n * - macOS/Linux: ~/.local/bin/aptos\n * - Windows: $USERPROFILE\\.aptoscli\\bin\\aptos.exe\n */\nexport const getLocalBinPath = (): string => {\n // Fast path: return cached binary location if still valid\n const cached = readCachedBinPath();\n if (cached) {\n return cached;\n }\n\n const os = getOS();\n\n // On macOS, prefer Homebrew installation if it exists\n if (os === \"MacOS\") {\n if (isInstalledViaBrew()) {\n try {\n const brewPath = getCliPathBrew();\n writeCachedBinPath(brewPath);\n return brewPath;\n } catch {\n // Fall through to default path\n }\n }\n }\n\n // On Windows, check for winget or Chocolatey installations\n if (os === \"Windows\") {\n if (isInstalledViaWinget()) {\n const wingetPath = getCliPathWinget();\n if (wingetPath) {\n writeCachedBinPath(wingetPath);\n return wingetPath;\n }\n }\n\n if (isInstalledViaChoco()) {\n const chocoPath = getCliPathChoco();\n if (chocoPath) {\n writeCachedBinPath(chocoPath);\n return chocoPath;\n }\n }\n }\n\n const binDir = getBinDir();\n const binaryName = os === \"Windows\" ? \"aptos.exe\" : \"aptos\";\n const defaultPath = join(binDir, binaryName);\n writeCachedBinPath(defaultPath);\n return defaultPath;\n};\n"]}

+92

-6

dist/utils/getUserOs.js

		@@ -1,15 +0,101 @@
		import { platform } from "os";
		export const getOS = () => {
		import { existsSync, readFileSync } from "node:fs";
		import { arch, platform } from "node:os";
		export const getPlatformInfo = () => {
		const osPlatform = platform();
		const osArch = arch();
		let os;
		switch (osPlatform) {
		case "darwin":
		return "MacOS";
		os = "macos";
		break;
		case "linux":
		return "Ubuntu";
		os = "linux";
		break;
		case "win32":
		return "Windows";
		os = "windows";
		break;
		default:
		throw new Error(`Unsupported OS ${osPlatform}`);
		throw new Error(`Unsupported operating system: ${osPlatform}`);
		}
		let architecture;
		switch (osArch) {
		case "x64":
		case "x86_64":
		architecture = "x86_64";
		break;
		case "arm64":
		case "aarch64":
		architecture = "aarch64";
		break;
		default:
		throw new Error(`Unsupported architecture: ${osArch}`);
		}
		return { os, arch: architecture };
		};
		const getLinuxDistroInfo = () => {
		const osReleasePath = "/etc/os-release";
		if (!existsSync(osReleasePath)) {
		return null;
		}
		try {
		const content = readFileSync(osReleasePath, "utf8");
		const lines = content.split("\n");
		let id = "";
		let versionId = "";
		for (const line of lines) {
		const [key, ...valueParts] = line.split("=");
		const value = valueParts.join("=").replace(/^["']\|["']$/g, "");
		if (key === "ID") {
		id = value.toLowerCase();
		}
		else if (key === "VERSION_ID") {
		versionId = value;
		}
		}
		return { id, versionId };
		}
		catch {
		return null;
		}
		};
		export const getTargetPlatform = () => {
		const { os, arch: architecture } = getPlatformInfo();
		switch (os) {
		case "macos":
		return architecture === "aarch64" ? "macos-arm64" : "macos-x86_64";
		case "linux": {
		if (architecture === "aarch64") {
		return "Linux-aarch64";
		}
		const distroInfo = getLinuxDistroInfo();
		if (distroInfo?.id === "ubuntu") {
		if (distroInfo.versionId.startsWith("24.04")) {
		return "Ubuntu-24.04-x86_64";
		}
		if (distroInfo.versionId.startsWith("22.04")) {
		return "Ubuntu-22.04-x86_64";
		}
		}
		return "Linux-x86_64";
		}
		case "windows":
		if (architecture === "aarch64") {
		throw new Error("Windows ARM64 is not currently supported. Please use x86_64 emulation or build from source.");
		}
		return "Windows-x86_64";
		default:
		throw new Error(`Unsupported OS: ${os}`);
		}
		};
		export const getOS = () => {
		const { os } = getPlatformInfo();
		switch (os) {
		case "macos":
		return "MacOS";
		case "linux":
		return "Linux";
		case "windows":
		return "Windows";
		}
		};
		//# sourceMappingURL=getUserOs.js.map

+1

-1

dist/utils/getUserOs.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"getUserOs.js","sourceRoot":"","sources":["../../bin/utils/getUserOs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAK9B,MAAM,CAAC,MAAM,KAAK,GAAG,GAAG,EAAE;IACxB,MAAM,UAAU,GAAG,QAAQ,EAAE,CAAC;IAC9B,QAAQ,UAAU,EAAE,CAAC;QACnB,KAAK,QAAQ;YACX,OAAO,OAAO,CAAC;QACjB,KAAK,OAAO;YACV,OAAO,QAAQ,CAAC;QAClB,KAAK,OAAO;YACV,OAAO,SAAS,CAAC;QACnB;YACE,MAAM,IAAI,KAAK,CAAC,kBAAkB,UAAU,EAAE,CAAC,CAAC;IACpD,CAAC;AACH,CAAC,CAAC"}
		{"version":3,"file":"getUserOs.js","sourceRoot":"","sources":["../../bin/utils/getUserOs.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync, readFileSync } from \"node:fs\";\nimport { arch, platform } from \"node:os\";\n\nexport type SupportedOS = \"macos\" \| \"linux\" \| \"windows\";\nexport type SupportedArch = \"x86_64\" \| \"aarch64\";\n\nexport interface PlatformInfo {\n os: SupportedOS;\n arch: SupportedArch;\n}\n\n/*\n Target strings that match the official Aptos CLI release artifacts.\n * These are derived from the official install scripts at:\n * - https://aptos.dev/scripts/install_cli.sh\n * - https://aptos.dev/scripts/install_cli.ps1\n /\nexport type TargetPlatform =\n \| \"macos-x86_64\"\n \| \"macos-arm64\"\n \| \"Ubuntu-22.04-x86_64\"\n \| \"Ubuntu-24.04-x86_64\"\n \| \"Linux-x86_64\"\n \| \"Linux-aarch64\"\n \| \"Windows-x86_64\";\n\n/\n Get basic OS and architecture information.\n /\nexport const getPlatformInfo = (): PlatformInfo => {\n const osPlatform = platform();\n const osArch = arch();\n\n let os: SupportedOS;\n switch (osPlatform) {\n case \"darwin\":\n os = \"macos\";\n break;\n case \"linux\":\n os = \"linux\";\n break;\n case \"win32\":\n os = \"windows\";\n break;\n default:\n throw new Error(`Unsupported operating system: ${osPlatform}`);\n }\n\n let architecture: SupportedArch;\n switch (osArch) {\n case \"x64\":\n case \"x86_64\":\n architecture = \"x86_64\";\n break;\n case \"arm64\":\n case \"aarch64\":\n architecture = \"aarch64\";\n break;\n default:\n throw new Error(`Unsupported architecture: ${osArch}`);\n }\n\n return { os, arch: architecture };\n};\n\n/\n Parse /etc/os-release file to get distribution info.\n * Returns null if file doesn't exist or can't be parsed.\n /\nconst getLinuxDistroInfo = (): { id: string; versionId: string } \| null => {\n const osReleasePath = \"/etc/os-release\";\n if (!existsSync(osReleasePath)) {\n return null;\n }\n\n try {\n const content = readFileSync(osReleasePath, \"utf8\");\n const lines = content.split(\"\\n\");\n\n let id = \"\";\n let versionId = \"\";\n\n for (const line of lines) {\n const [key, ...valueParts] = line.split(\"=\");\n const value = valueParts.join(\"=\").replace(/^[\"']\|[\"']$/g, \"\");\n\n if (key === \"ID\") {\n id = value.toLowerCase();\n } else if (key === \"VERSION_ID\") {\n versionId = value;\n }\n }\n\n return { id, versionId };\n } catch {\n return null;\n }\n};\n\n/\n Determine the target platform string for downloading the CLI binary.\n * This matches the naming convention used in official Aptos CLI releases.\n /\nexport const getTargetPlatform = (): TargetPlatform => {\n const { os, arch: architecture } = getPlatformInfo();\n\n switch (os) {\n case \"macos\":\n // macOS supports both x86_64 and arm64\n return architecture === \"aarch64\" ? \"macos-arm64\" : \"macos-x86_64\";\n\n case \"linux\": {\n // Check for ARM64 first\n if (architecture === \"aarch64\") {\n return \"Linux-aarch64\";\n }\n\n // For x86_64, check if we're on Ubuntu and what version\n const distroInfo = getLinuxDistroInfo();\n if (distroInfo?.id === \"ubuntu\") {\n if (distroInfo.versionId.startsWith(\"24.04\")) {\n return \"Ubuntu-24.04-x86_64\";\n }\n if (distroInfo.versionId.startsWith(\"22.04\")) {\n return \"Ubuntu-22.04-x86_64\";\n }\n }\n\n // Default to generic Linux for non-Ubuntu or older Ubuntu versions\n return \"Linux-x86_64\";\n }\n\n case \"windows\":\n // Windows only supports x86_64 currently\n if (architecture === \"aarch64\") {\n throw new Error(\n \"Windows ARM64 is not currently supported. Please use x86_64 emulation or build from source.\",\n );\n }\n return \"Windows-x86_64\";\n\n default:\n throw new Error(`Unsupported OS: ${os}`);\n }\n};\n\n/\n Get simple OS identifier for branching logic.\n * @deprecated Use getPlatformInfo() or getTargetPlatform() instead for more precise platform detection.\n */\nexport const getOS = (): \"MacOS\" \| \"Linux\" \| \"Windows\" => {\n const { os } = getPlatformInfo();\n switch (os) {\n case \"macos\":\n return \"MacOS\";\n case \"linux\":\n return \"Linux\";\n case \"windows\":\n return \"Windows\";\n }\n};\n"]}

+81

-6

dist/utils/ghOperations.js

		@@ -1,12 +0,87 @@
		import { PNAME } from "./consts.js";
		import { GH_CLI_DOWNLOAD_URL, PNAME } from "./consts.js";
		const getGitHubHeaders = () => {
		const headers = {
		Accept: "application/vnd.github.v3+json",
		"User-Agent": "aptos-cli-npm",
		};
		const token = process.env.GITHUB_TOKEN;
		if (token) {
		headers.Authorization = `Bearer ${token}`;
		}
		return headers;
		};
		export const getUserSpecifiedVersion = () => {
		const version = process.env.APTOS_CLI_VERSION;
		if (!version) {
		return undefined;
		}
		const stripped = version.replace(/^v/, "");
		if (!/^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/.test(stripped)) {
		throw new Error(`Invalid APTOS_CLI_VERSION: "${version}". Must match MAJOR.MINOR.PATCH (e.g. "4.5.0" or "v4.5.0").`);
		}
		return stripped;
		};
		export const hasUserSpecifiedVersion = () => {
		return !!process.env.APTOS_CLI_VERSION;
		};
		export const validateVersionExists = async (version, targetPlatform) => {
		const url = `${GH_CLI_DOWNLOAD_URL}/${PNAME}-v${version}/${PNAME}-${version}-${targetPlatform}.zip`;
		try {
		const response = await fetch(url, {
		method: "HEAD",
		headers: getGitHubHeaders(),
		});
		return response.ok;
		}
		catch {
		return false;
		}
		};
		export const getCliVersion = async (targetPlatform) => {
		const userVersion = getUserSpecifiedVersion();
		if (userVersion) {
		if (targetPlatform) {
		const exists = await validateVersionExists(userVersion, targetPlatform);
		if (!exists) {
		throw new Error(`Specified version ${userVersion} does not exist or is not available for ${targetPlatform}. ` +
		`Check https://github.com/aptos-labs/aptos-core/releases for available versions.`);
		}
		}
		return userVersion;
		}
		return getLatestVersionGh();
		};
		export const getLatestVersionGh = async () => {
		const prefix = `${PNAME}-v`;
		const response = await (await fetch("https://api.github.com/repos/aptos-labs/aptos-core/releases?per_page=100")).json();
		for (const release of response) {
		if (release["tag_name"].startsWith(`${prefix}`)) {
		return release.tag_name.replace(`${prefix}`, "");
		const url = "https://api.github.com/repos/aptos-labs/aptos-core/releases?per_page=100";
		let response;
		try {
		response = await fetch(url, { headers: getGitHubHeaders() });
		}
		catch (error) {
		throw new Error(`Failed to fetch releases from GitHub: ${error instanceof Error ? error.message : String(error)}`);
		}
		if (!response.ok) {
		if (response.status === 403 \|\| response.status === 429) {
		throw new Error("GitHub API rate limit exceeded. Please try again later or set a GITHUB_TOKEN environment variable.");
		}
		throw new Error(`GitHub API request failed with status ${response.status}: ${response.statusText}`);
		}
		throw "Could not determine latest version of Aptos CLI";
		let releases;
		try {
		releases = await response.json();
		}
		catch {
		throw new Error("Failed to parse GitHub API response as JSON");
		}
		if (!Array.isArray(releases)) {
		throw new Error("Unexpected response format from GitHub API");
		}
		for (const release of releases) {
		if (release.tag_name?.startsWith(prefix)) {
		return release.tag_name.replace(prefix, "");
		}
		}
		throw new Error("Could not determine latest version of Aptos CLI. No matching release found in the last 100 releases.");
		};
		//# sourceMappingURL=ghOperations.js.map

+1

-1

dist/utils/ghOperations.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"ghOperations.js","sourceRoot":"","sources":["../../bin/utils/ghOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAMpC,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,IAAI,EAAE;IAC3C,MAAM,MAAM,GAAG,GAAG,KAAK,IAAI,CAAC;IAC5B,MAAM,QAAQ,GAAG,MAAM,CACrB,MAAM,KAAK,CACT,0EAA0E,CAC3E,CACF,CAAC,IAAI,EAAE,CAAC;IACT,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,CAAC;YAChD,OAAO,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;IACD,MAAM,iDAAiD,CAAC;AAC1D,CAAC,CAAC"}
		{"version":3,"file":"ghOperations.js","sourceRoot":"","sources":["../../bin/utils/ghOperations.ts"],"names":[],"mappings":"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","sourcesContent":["import { GH_CLI_DOWNLOAD_URL, PNAME } from \"./consts.js\";\n\ninterface GitHubRelease {\n tag_name: string;\n [key: string]: unknown;\n}\n\n/*\n Build headers for GitHub API requests.\n * Uses GITHUB_TOKEN environment variable if available for authenticated requests.\n /\nconst getGitHubHeaders = (): Record<string, string> => {\n const headers: Record<string, string> = {\n Accept: \"application/vnd.github.v3+json\",\n \"User-Agent\": \"aptos-cli-npm\",\n };\n\n // Use GITHUB_TOKEN if available for higher rate limits\n const token = process.env.GITHUB_TOKEN;\n if (token) {\n headers.Authorization = `Bearer ${token}`;\n }\n\n return headers;\n};\n\n/\n Get the user-specified CLI version from environment variable.\n * Returns undefined if not set.\n /\nexport const getUserSpecifiedVersion = (): string \| undefined => {\n const version = process.env.APTOS_CLI_VERSION;\n if (!version) {\n return undefined;\n }\n // Strip 'v' prefix if present (e.g., \"v1.2.3\" -> \"1.2.3\")\n const stripped = version.replace(/^v/, \"\");\n if (!/^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.]+)?$/.test(stripped)) {\n throw new Error(\n `Invalid APTOS_CLI_VERSION: \"${version}\". Must match MAJOR.MINOR.PATCH (e.g. \"4.5.0\" or \"v4.5.0\").`,\n );\n }\n return stripped;\n};\n\n/\n Check if a user has specified a CLI version via environment variable.\n /\nexport const hasUserSpecifiedVersion = (): boolean => {\n return !!process.env.APTOS_CLI_VERSION;\n};\n\n/\n Validate that a specific version exists by checking if the release assets are accessible.\n * Uses a HEAD request to avoid downloading the actual file.\n \n @param version - The version to validate (without 'v' prefix)\n * @param targetPlatform - The target platform string (e.g., \"Ubuntu-22.04-x86_64\")\n /\nexport const validateVersionExists = async (\n version: string,\n targetPlatform: string,\n): Promise<boolean> => {\n const url = `${GH_CLI_DOWNLOAD_URL}/${PNAME}-v${version}/${PNAME}-${version}-${targetPlatform}.zip`;\n\n try {\n const response = await fetch(url, {\n method: \"HEAD\",\n headers: getGitHubHeaders(),\n });\n return response.ok;\n } catch {\n return false;\n }\n};\n\n/\n Get the CLI version to use.\n * If APTOS_CLI_VERSION is set, returns that version (after validation).\n * Otherwise, returns the latest version from GitHub.\n \n @param targetPlatform - Optional target platform for version validation\n /\nexport const getCliVersion = async (\n targetPlatform?: string,\n): Promise<string> => {\n const userVersion = getUserSpecifiedVersion();\n\n if (userVersion) {\n // If a target platform is provided, validate the version exists\n if (targetPlatform) {\n const exists = await validateVersionExists(userVersion, targetPlatform);\n if (!exists) {\n throw new Error(\n `Specified version ${userVersion} does not exist or is not available for ${targetPlatform}. ` +\n `Check https://github.com/aptos-labs/aptos-core/releases for available versions.`,\n );\n }\n }\n return userVersion;\n }\n\n return getLatestVersionGh();\n};\n\n/\n Query the GitHub API to find the latest CLI release. We assume that the CLI is in\n * the last 100 releases so we don't paginate through the releases.\n \n Set GITHUB_TOKEN environment variable for higher rate limits.\n */\nexport const getLatestVersionGh = async (): Promise<string> => {\n const prefix = `${PNAME}-v`;\n const url =\n \"https://api.github.com/repos/aptos-labs/aptos-core/releases?per_page=100\";\n\n let response: Response;\n try {\n response = await fetch(url, { headers: getGitHubHeaders() });\n } catch (error) {\n throw new Error(\n `Failed to fetch releases from GitHub: ${error instanceof Error ? error.message : String(error)}`,\n );\n }\n\n if (!response.ok) {\n if (response.status === 403 \|\| response.status === 429) {\n throw new Error(\n \"GitHub API rate limit exceeded. Please try again later or set a GITHUB_TOKEN environment variable.\",\n );\n }\n throw new Error(\n `GitHub API request failed with status ${response.status}: ${response.statusText}`,\n );\n }\n\n let releases: GitHubRelease[];\n try {\n releases = await response.json();\n } catch {\n throw new Error(\"Failed to parse GitHub API response as JSON\");\n }\n\n if (!Array.isArray(releases)) {\n throw new Error(\"Unexpected response format from GitHub API\");\n }\n\n for (const release of releases) {\n if (release.tag_name?.startsWith(prefix)) {\n return release.tag_name.replace(prefix, \"\");\n }\n }\n\n throw new Error(\n \"Could not determine latest version of Aptos CLI. No matching release found in the last 100 releases.\",\n );\n};\n"]}

+4

-4

dist/utils/parseCommandOptions.js

		@@ -1,2 +0,2 @@
		import { existsSync } from "fs";
		import { existsSync } from "node:fs";
		import { installCli } from "../tasks/install.js";
		@@ -8,7 +8,7 @@ import { runCLI } from "../tasks/run.js";
		if (options.install) {
		await installCli();
		await installCli(options.directDownload);
		return;
		}
		if (options.update) {
		await updateCli();
		await updateCli(options.directDownload);
		return;
		@@ -18,3 +18,3 @@ }
		if (!options.binaryPath && !existsSync(path)) {
		await installCli();
		await installCli(options.directDownload);
		}
		@@ -21,0 +21,0 @@ await runCLI(unknownOptions, options.binaryPath);

+1

-1

dist/utils/parseCommandOptions.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"parseCommandOptions.js","sourceRoot":"","sources":["../../bin/utils/parseCommandOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,EACtC,OAAmE,EACnE,cAAwB,EACxB,EAAE;IAEF,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,UAAU,EAAE,CAAC;QACnB,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACnB,MAAM,SAAS,EAAE,CAAC;QAClB,OAAO;IACT,CAAC;IAGD,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,IAAI,eAAe,EAAE,CAAC;IACrD,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7C,MAAM,UAAU,EAAE,CAAC;IACrB,CAAC;IACD,MAAM,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;AACnD,CAAC,CAAC"}
		{"version":3,"file":"parseCommandOptions.js","sourceRoot":"","sources":["../../bin/utils/parseCommandOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAcvD,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,EACtC,OAAuB,EACvB,cAAwB,EACT,EAAE;IAEjB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,UAAU,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACzC,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACnB,MAAM,SAAS,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACxC,OAAO;IACT,CAAC;IAGD,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,IAAI,eAAe,EAAE,CAAC;IACrD,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7C,MAAM,UAAU,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC;IACD,MAAM,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;AACnD,CAAC,CAAC","sourcesContent":["import { existsSync } from \"node:fs\";\nimport { installCli } from \"../tasks/install.js\";\nimport { runCLI } from \"../tasks/run.js\";\nimport { updateCli } from \"../tasks/update.js\";\nimport { getLocalBinPath } from \"./getLocalBinPath.js\";\n\ninterface CommandOptions {\n install: boolean;\n update: boolean;\n binaryPath?: string;\n directDownload?: boolean;\n}\n\n/*\n Parse and handle command options for the Aptos CLI wrapper.\n * @param options - The parsed command options\n * @param unknownOptions - Additional arguments to pass through to the CLI\n */\nexport const parseCommandOptions = async (\n options: CommandOptions,\n unknownOptions: string[],\n): Promise<void> => {\n // if `--install` flag is set, only install the cli and don't run it\n if (options.install) {\n await installCli(options.directDownload);\n return;\n }\n // if `--update` flag is set, update the cli and don't run it\n if (options.update) {\n await updateCli(options.directDownload);\n return;\n }\n\n // if no flags are set, install and run the cli\n const path = options.binaryPath \|\| getLocalBinPath();\n if (!options.binaryPath && !existsSync(path)) {\n await installCli(options.directDownload);\n }\n await runCLI(unknownOptions, options.binaryPath);\n};\n"]}

+22

-11

package.json

		{
		"name": "@aptos-labs/aptos-cli",
		"version": "1.1.1",
		"version": "2.0.0",
		"description": "Aptos CLI available from npmjs",
		"engines": {
		"node": ">=22"
		},
		"bin": {
		@@ -22,18 +25,26 @@ "aptos": "./dist/aptos.js"
		"license": "Apache-2.0",
		"scripts": {
		"clean": "rm -rf dist",
		"build": "npm run clean && tsc",
		"dev": "npm run build && node ./dist/aptos.js"
		},
		"sideEffects": false,
		"exports": {},
		"files": [
		"bin",
		"dist"
		],
		"dependencies": {
		"commander": "^12.1.0"
		"commander": "^14.0.3"
		},
		"devDependencies": {
		"@types/node": "^20.5.0",
		"typescript": "^5.6.2"
		"@biomejs/biome": "^2.4.6",
		"@types/node": "^22",
		"typescript": "^5.9.3",
		"vitest": "^4.0.18"
		},
		"scripts": {
		"clean": "node --input-type=commonjs -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
		"build": "pnpm run clean && tsc",
		"dev": "pnpm run build && node ./dist/aptos.js",
		"test": "vitest run",
		"test:watch": "vitest",
		"check": "biome check",
		"check:fix": "biome check --fix",
		"format": "biome format --fix"
		}
		}
		}

+109

-0

README.md

		@@ -45,2 +45,24 @@ # Aptos CLI

		### Installing a Specific Version

		You can install a specific version of the Aptos CLI by setting the `APTOS_CLI_VERSION` environment variable:

		```bash
		# Install version 4.5.0
		APTOS_CLI_VERSION=4.5.0 npx aptos --install

		# Or with the v prefix
		APTOS_CLI_VERSION=v4.5.0 npx aptos --install
		```

		When `APTOS_CLI_VERSION` is set:
		- The specified version is downloaded directly from GitHub releases (package managers are bypassed)
		- The version is validated to ensure it exists before downloading
		- This works for both `--install` and `--update` commands

		This is useful for:
		- Pinning to a known working version
		- Testing against specific CLI versions
		- Reproducible builds in CI/CD pipelines

		## Updating the Aptos CLI
		@@ -77,1 +99,88 @@
		```

		## Building Move Artifacts in CI/CD

		The Aptos CLI can be used in CI/CD pipelines to build Move packages and generate deployment payloads. This is useful for automated deployments and multi-step workflows.

		### Example: Building Publish Payload

		```yaml
		# In your GitHub Actions workflow

		# Prerequisites: Set up Node.js first
		- name: Setup Node.js
		uses: actions/setup-node@v4
		with:
		node-version: "20"

		- name: Install Aptos CLI npm package
		run: npm install @aptos-labs/aptos-cli

		- name: Install Aptos CLI
		run: npx aptos --install

		- name: Build Move package
		working-directory: your-move-project
		run: \|
		~/.local/bin/aptos move compile \
		--named-addresses your_module=0x1 \
		--save-metadata

		- name: Generate publish payload
		working-directory: your-move-project
		run: \|
		~/.local/bin/aptos move build-publish-payload \
		--named-addresses your_module=0x1 \
		--json-output-file publish-payload.json \
		--assume-yes

		- name: Upload artifact for later steps
		uses: actions/upload-artifact@v4
		with:
		name: move-artifacts
		path: your-move-project/publish-payload.json
		```

		### Example: Building Upgrade Payload (Object Code Deployment)

		For upgrading existing object-deployed contracts:

		```yaml
		- name: Generate upgrade payload
		working-directory: your-move-project
		run: \|
		~/.local/bin/aptos move build-upgrade-payload \
		--named-addresses your_module=0x1 \
		--object-address 0xYOUR_OBJECT_ADDRESS \
		--json-output-file upgrade-payload.json \
		--assume-yes
		```

		### Using Artifacts in Subsequent Jobs

		```yaml
		jobs:
		build:
		runs-on: ubuntu-latest
		steps:
		# ... build steps above ...
		- uses: actions/upload-artifact@v4
		with:
		name: move-artifacts
		path: your-move-project/publish-payload.json

		deploy:
		needs: build
		runs-on: ubuntu-latest
		steps:
		- uses: actions/download-artifact@v4
		with:
		name: move-artifacts

		- name: Use the payload
		run: \|
		# The payload JSON can be used for deployment
		cat publish-payload.json
		```

		See the [build-move-artifacts.yaml](.github/workflows/build-move-artifacts.yaml) workflow for a complete working example.

bin/.gitkeep

Sorry, the diff of this file is not supported yet

-44

bin/aptos.ts

		#!/usr/bin/env node

		// On MacOS we install the CLI with brew. There are two main reasons for this:
		// 1. Brew builds the CLI for the native CPU architecture for the user, which
		// eliminates any issues arising from using x86 binaries on ARM machines.
		// 2. Brew handles dependency management for us. This isn't relevant right now but
		// might become necessary later if we reintroduce OpenSSL as a dep for the CLI.
		//
		// On Linux and Windows we just query the GH API for the latest CLI release and
		// download and extract that.

		import { program } from "commander";

		import { parseCommandOptions } from "./utils/parseCommandOptions.js";
		import { runCLI } from "./tasks/run.js";

		program
		.name("aptos")
		.helpOption(false)
		.option("-i, --install", "install the latest version of the CLI")
		.option("-u, --update", "update the CLI to the latest version")
		.option("-b, --binary-path <path>", "path to an existing Aptos CLI binary")
		.allowUnknownOption();

		program.parse(process.argv);

		const main = async () => {
		const options = {
		install: program.opts().install,
		update: program.opts().update,
		binaryPath: program.opts().binaryPath,
		};
		const unknownOptions = program.args;

		// Manually check for `--help` and handle the CLI `--help`
		if (process.argv.includes("--help")) {
		// Forward to the CLI
		return runCLI(unknownOptions, options.binaryPath);
		}

		await parseCommandOptions(options, unknownOptions);
		};

		main().catch(console.error);

-55

bin/tasks/install.ts

		import { execSync } from "child_process";
		import { existsSync } from "fs";

		import { GH_CLI_DOWNLOAD_URL, PNAME } from "../utils/consts.js";
		import { execSyncShell } from "../utils/execSyncShell.js";
		import { getCurrentOpenSSLVersion } from "../utils/versions.js";
		import { getOS } from "../utils/getUserOs.js";
		import { getLocalBinPath } from "../utils/getLocalBinPath.js";
		import { getLatestVersionGh } from "../utils/ghOperations.js";

		// Install the CLI.
		export const installCli = async () => {
		const path = getLocalBinPath();
		if (existsSync(path)) {
		console.log("Aptos CLI is already installed");
		return;
		}
		// Look up the latest version.
		const latestCLIVersion = await getLatestVersionGh();
		console.log(`Downloading aptos CLI version ${latestCLIVersion}`);
		const os = getOS();

		if (os === "Windows") {
		const url = `${GH_CLI_DOWNLOAD_URL}/${PNAME}-v${latestCLIVersion}/${PNAME}-${latestCLIVersion}-${os}-x86_64.zip`;
		// Download the zip file, extract it, and move the binary to the correct location.
		execSync(
		`powershell -Command "if (!(Test-Path -Path 'C:\\tmp')) { New-Item -ItemType Directory -Path 'C:\\tmp' } ; Invoke-RestMethod -Uri ${url} -OutFile C:\\tmp\\aptos.zip; Expand-Archive -Path C:\\tmp\\aptos.zip -DestinationPath C:\\tmp -Force; Move-Item -Path C:\\tmp\\aptos.exe -Destination \"${path}\""`
		);
		} else if (os === "MacOS") {
		// Install the CLI with brew.
		execSyncShell("brew install aptos", { encoding: "utf8" });
		} else {
		// On Linux, we check what version of OpenSSL we're working with to figure out
		// which binary to download.
		let osVersion = "x86_64";
		let opensSslVersion = "1.0.0";
		try {
		opensSslVersion = getCurrentOpenSSLVersion();
		} catch (error) {
		console.log(
		"Could not determine OpenSSL version, assuming older version (1.x.x)"
		);
		}

		if (opensSslVersion.startsWith("3.")) {
		osVersion = "22.04-x86_64";
		}
		console.log(`Downloading CLI binary ${os}-${osVersion}`);
		const url = `${GH_CLI_DOWNLOAD_URL}/${PNAME}-v${latestCLIVersion}/${PNAME}-${latestCLIVersion}-${os}-${osVersion}.zip`;
		// Download the zip file, extract it, and move the binary to the correct location.
		execSync(
		`curl -L -o /tmp/aptos.zip ${url}; unzip -o -q /tmp/aptos.zip -d /tmp; mv /tmp/aptos ${path};`
		);
		}
		};

-27

bin/tasks/run.ts

		import { spawn } from "child_process";
		import { existsSync } from "fs";

		import { getOS } from "../utils/getUserOs.js";
		import { getLocalBinPath } from "../utils/getLocalBinPath.js";

		export const runCLI = async (args: string[] = [], binaryPath?: string) => {
		const path = binaryPath \|\| getLocalBinPath();
		if (!existsSync(path)) {
		if (binaryPath) {
		console.error(`Error: Binary not found at specified path: ${binaryPath}`);
		process.exit(1);
		}
		console.log(
		"Aptos CLI not installed, run `npx aptos --install` to install"
		);
		return;
		}
		const os = getOS();

		// Spawn a child process to execute the binary with the provided arguments.
		// Spawn the child process to run the real CLI executable with the forwarded arguments
		spawn(path, args, {
		stdio: "inherit", // Forward the stdio so output is visible
		shell: os === "Windows", // Use shell on Windows
		});
		};

-41

bin/tasks/update.ts

		import { existsSync } from "fs";

		import { getLocalBinPath } from "../utils/getLocalBinPath.js";
		import { execSync } from "child_process";
		import { getOS } from "../utils/getUserOs.js";
		import { getLatestVersionGh } from "../utils/ghOperations.js";
		import { execSyncShell } from "../utils/execSyncShell.js";
		import { installCli } from "./install.js";

		export const updateCli = async () => {
		const path = getLocalBinPath();

		if (!existsSync(path)) {
		console.log(
		"Aptos CLI not installed, run `npx aptos --install` to install"
		);
		return;
		}

		if (getOS() === "MacOS") {
		// Upgrade aptos via brew.
		return execSync("brew upgrade aptos");
		} else {
		const latestVersion = await getLatestVersionGh();
		// Get the current version of the CLI.
		const currentVersion = execSyncShell(`${path} --version`, {
		encoding: "utf8",
		})
		.trim()
		.split(" ")[1];
		// Check if the installed version is the latest version.
		if (currentVersion !== latestVersion) {
		console.log(
		`A newer version of the CLI is available: ${latestVersion}, installing...`
		);
		await installCli();
		} else {
		console.log(`CLI is up to date`);
		}
		}
		};

-14

bin/utils/aptosExecutableIsAvailable.ts

		import { execSyncShell } from "./execSyncShell.js";

		/**
		* Only works on Unix systems. This is fine because we only need to check for brew on
		* MacOS.
		*/
		export const executableIsAvailable = (name) => {
		try {
		execSyncShell(`which ${name}`, { encoding: "utf8" });
		return true;
		} catch (error) {
		return false;
		}
		};

-12

bin/utils/brewOperations.ts

		import { execSyncShell } from "./execSyncShell.js";

		/**
		* Based on the installation path of the aptos formula, determine the path where the
		* CLI should be installed.
		*/
		export const getCliPathBrew = () => {
		const directory = execSyncShell("brew --prefix aptos", { encoding: "utf8" })
		.toString()
		.trim();
		return `${directory}/bin/aptos`;
		};

-3

bin/utils/consts.ts

		export const PNAME = "aptos-cli";
		export const GH_CLI_DOWNLOAD_URL =
		"https://github.com/aptos-labs/aptos-core/releases/download";

-8

bin/utils/execSyncShell.ts

		import { execSync } from "child_process";

		/**
		* Wrapper around execSync that uses the shell.
		*/
		export const execSyncShell = (command, options) => {
		return execSync(command, { shell: true, ...options });
		};

-28

bin/utils/getLocalBinPath.ts

		import { dirname } from "path";
		import { executableIsAvailable } from "./aptosExecutableIsAvailable.js";
		import { getCliPathBrew } from "./brewOperations.js";
		import { PNAME } from "./consts.js";
		import { getOS } from "./getUserOs.js";
		import { fileURLToPath } from "url";

		export const getLocalBinPath = () => {
		let path;
		const os = getOS();
		if (os === "MacOS") {
		// Confirm brew is installed.
		const brewInstalled = executableIsAvailable("brew");
		if (!brewInstalled) {
		throw "Please install brew to continue: https://brew.sh/";
		}
		try {
		path = getCliPathBrew();
		} catch (e) {
		path = "";
		}
		} else if (os === "Windows") {
		path = `${dirname(fileURLToPath(import.meta.url))}\\${PNAME}.exe`;
		} else {
		path = `${dirname(fileURLToPath(import.meta.url))}/${PNAME}`;
		}
		return path;
		};

-18

bin/utils/getUserOs.ts

		import { platform } from "os";

		/**
		* Determine what OS we're running on.
		*/
		export const getOS = () => {
		const osPlatform = platform();
		switch (osPlatform) {
		case "darwin":
		return "MacOS";
		case "linux":
		return "Ubuntu";
		case "win32":
		return "Windows";
		default:
		throw new Error(`Unsupported OS ${osPlatform}`);
		}
		};

-20

bin/utils/ghOperations.ts

		import { PNAME } from "./consts.js";

		/**
		* Query the GitHub API to find the latest CLI release. We assume that the CLI is in
		* the last 100 releases so we don't paginate through the releases.
		*/
		export const getLatestVersionGh = async () => {
		const prefix = `${PNAME}-v`;
		const response = await (
		await fetch(
		"https://api.github.com/repos/aptos-labs/aptos-core/releases?per_page=100"
		)
		).json();
		for (const release of response) {
		if (release["tag_name"].startsWith(`${prefix}`)) {
		return release.tag_name.replace(`${prefix}`, "");
		}
		}
		throw "Could not determine latest version of Aptos CLI";
		};

-38

bin/utils/handleHelpOptions.ts

		import { spawnSync } from "child_process";
		import { Command } from "commander";

		/**
		* Handle the `--help` option for the Aptos CLI. This function is used to combine
		* the Aptos CLI help output with the Commander help output.
		* @param program - The Commander program instance.
		* @param unknownOptions - The unknown options passed to the CLI.
		* @returns void
		*/
		export const handleHelpOptions = (
		program: Command,
		unknownOptions: string[]
		) => {
		// Capture the Aptos CLI help output
		const cliHelp = spawnSync(`aptos`, unknownOptions, {
		stdio: "pipe",
		encoding: "utf-8",
		});
		// Generate Commander help text
		const commanderHelp = program.helpInformation();

		// Remove the "Usage" and "Options" lines from the Commander output
		const commanderOptionsOnly = commanderHelp
		.split("\n")
		.filter((line) => !line.startsWith("Usage") && !line.startsWith("Options"))
		.join("\n");

		// Find where the CLI options start and append the Commander options to the existing CLI options
		const combinedHelp = cliHelp.stdout.replace(
		"Options:",
		`Options:\n${commanderOptionsOnly.trim()}`
		);

		// Output the combined help
		console.log(combinedHelp);
		return;
		};

-28

bin/utils/parseCommandOptions.ts

		import { existsSync } from "fs";
		import { installCli } from "../tasks/install.js";
		import { runCLI } from "../tasks/run.js";
		import { updateCli } from "../tasks/update.js";
		import { getLocalBinPath } from "./getLocalBinPath.js";

		export const parseCommandOptions = async (
		options: { install: boolean; update: boolean; binaryPath?: string },
		unknownOptions: string[]
		) => {
		// if `--install` flag is set, only install the cli and dont run it
		if (options.install) {
		await installCli();
		return;
		}
		// if `--update` flag is set, update the cli and dont run it
		if (options.update) {
		await updateCli();
		return;
		}

		// if no flags are set, install and run the cli
		const path = options.binaryPath \|\| getLocalBinPath();
		if (!options.binaryPath && !existsSync(path)) {
		await installCli();
		}
		await runCLI(unknownOptions, options.binaryPath);
		};

-9

bin/utils/versions.ts

		import { execSyncShell } from "./execSyncShell.js";

		/**
		* Determine the current SSL version
		*/
		export const getCurrentOpenSSLVersion = () => {
		const out = execSyncShell("openssl version", { encoding: "utf8" });
		return out.split(" ")[1].trim();
		};

-2

dist/aptos.d.ts

		#!/usr/bin/env node
		export {};

-1

dist/tasks/install.d.ts

export declare const installCli: () => Promise<void>;

-1

dist/tasks/run.d.ts

export declare const runCLI: (args?: string[], binaryPath?: string) => Promise<void>;

-1

dist/tasks/update.d.ts

export declare const updateCli: () => Promise<NonSharedBuffer | undefined>;

-1

dist/utils/aptosExecutableIsAvailable.d.ts

export declare const executableIsAvailable: (name: any) => boolean;

-11

dist/utils/aptosExecutableIsAvailable.js

		import { execSyncShell } from "./execSyncShell.js";
		export const executableIsAvailable = (name) => {
		try {
		execSyncShell(`which ${name}`, { encoding: "utf8" });
		return true;
		}
		catch (error) {
		return false;
		}
		};
		//# sourceMappingURL=aptosExecutableIsAvailable.js.map

-1

dist/utils/aptosExecutableIsAvailable.js.map

{"version":3,"file":"aptosExecutableIsAvailable.js","sourceRoot":"","sources":["../../bin/utils/aptosExecutableIsAvailable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAMnD,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,EAAE;IAC5C,IAAI,CAAC;QACH,aAAa,CAAC,SAAS,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;QACrD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC"}

-1

dist/utils/brewOperations.d.ts

export declare const getCliPathBrew: () => string;

-2

dist/utils/consts.d.ts

		export declare const PNAME = "aptos-cli";
		export declare const GH_CLI_DOWNLOAD_URL = "https://github.com/aptos-labs/aptos-core/releases/download";

-1

dist/utils/execSyncShell.d.ts

export declare const execSyncShell: (command: any, options: any) => string;

-1

dist/utils/getLocalBinPath.d.ts

export declare const getLocalBinPath: () => any;

-1

dist/utils/getUserOs.d.ts

export declare const getOS: () => "MacOS" | "Ubuntu" | "Windows";

-1

dist/utils/ghOperations.d.ts

export declare const getLatestVersionGh: () => Promise<any>;

-2

dist/utils/handleHelpOptions.d.ts

		import { Command } from "commander";
		export declare const handleHelpOptions: (program: Command, unknownOptions: string[]) => void;

-16

dist/utils/handleHelpOptions.js

		import { spawnSync } from "child_process";
		export const handleHelpOptions = (program, unknownOptions) => {
		const cliHelp = spawnSync(`aptos`, unknownOptions, {
		stdio: "pipe",
		encoding: "utf-8",
		});
		const commanderHelp = program.helpInformation();
		const commanderOptionsOnly = commanderHelp
		.split("\n")
		.filter((line) => !line.startsWith("Usage") && !line.startsWith("Options"))
		.join("\n");
		const combinedHelp = cliHelp.stdout.replace("Options:", `Options:\n${commanderOptionsOnly.trim()}`);
		console.log(combinedHelp);
		return;
		};
		//# sourceMappingURL=handleHelpOptions.js.map

-1

dist/utils/handleHelpOptions.js.map

{"version":3,"file":"handleHelpOptions.js","sourceRoot":"","sources":["../../bin/utils/handleHelpOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAU1C,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,OAAgB,EAChB,cAAwB,EACxB,EAAE;IAEF,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE;QACjD,KAAK,EAAE,MAAM;QACb,QAAQ,EAAE,OAAO;KAClB,CAAC,CAAC;IAEH,MAAM,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAGhD,MAAM,oBAAoB,GAAG,aAAa;SACvC,KAAK,CAAC,IAAI,CAAC;SACX,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;SAC1E,IAAI,CAAC,IAAI,CAAC,CAAC;IAGd,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CACzC,UAAU,EACV,aAAa,oBAAoB,CAAC,IAAI,EAAE,EAAE,CAC3C,CAAC;IAGF,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAC1B,OAAO;AACT,CAAC,CAAC"}

-5

dist/utils/parseCommandOptions.d.ts

		export declare const parseCommandOptions: (options: {
		install: boolean;
		update: boolean;
		binaryPath?: string;
		}, unknownOptions: string[]) => Promise<void>;

-1

dist/utils/versions.d.ts

export declare const getCurrentOpenSSLVersion: () => string;

-6

dist/utils/versions.js

		import { execSyncShell } from "./execSyncShell.js";
		export const getCurrentOpenSSLVersion = () => {
		const out = execSyncShell("openssl version", { encoding: "utf8" });
		return out.split(" ")[1].trim();
		};
		//# sourceMappingURL=versions.js.map

-1

dist/utils/versions.js.map

{"version":3,"file":"versions.js","sourceRoot":"","sources":["../../bin/utils/versions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAKnD,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,EAAE;IAC3C,MAAM,GAAG,GAAG,aAAa,CAAC,iBAAiB,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IACnE,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AAClC,CAAC,CAAC"}

@aptos-labs/aptos-cli - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes