feat: support Go standard for target platform

TICKET: VL-4112

Author: louib

dist/index.js

@@ -1,6 +1,7 @@
 import type { Octokit } from "./octokit";
 import { isEqual, isSome, none, Option, some } from "./option";
 import { stripTargetTriple } from "./platform";
+import type { TargetDuple } from "./types";
 
 import {
   isExactSemanticVersion,
@@ -133,6 +134,7 @@ export async function fetchReleaseAssetMetadataFromTag(
   binaryName: Option<BinaryName>,
   tag: ExactSemanticVersion,
   targetTriple: TargetTriple,
+  targetDuple: TargetDuple,
 ): Promise<ReleaseAssetMetadata> {
   // Maintainer's note: this impure function call makes this function difficult to test.
   const releaseMetadata = await octokit.rest.repos.getReleaseByTag({
@@ -141,45 +143,52 @@ export async function fetchReleaseAssetMetadataFromTag(
     tag,
   });
 
-  // When the binary name is provided, look for matching binary and target triple.
+  // When the binary name is provided, look for matching binary with target triple or target duple
   if (isSome(binaryName)) {
-    const targetLabel = `${binaryName.value}-${targetTriple}`;
+    const targetLabelTraditional = `${binaryName.value}-${targetTriple}`;
+    const targetLabelDuple = `${binaryName.value}${targetDuple}`;
+
     const asset = releaseMetadata.data.assets.find(
-      (asset) => asset.label === targetLabel,
+      (asset) =>
+        typeof asset.label === "string" &&
+        (asset.label === targetLabelTraditional || asset.label === targetLabelDuple),
     );
+
     if (asset === undefined) {
       throw new Error(
-        `Expected to find asset in release ${slug.owner}/${slug.repository}@${tag} with label ${targetLabel}`,
+        `Expected to find asset in release ${slug.owner}/${slug.repository}@${tag} with label ${targetLabelTraditional} or ${targetLabelDuple}`,
       );
     }
+
     return {
       binaryName: binaryName,
       url: asset.url,
     };
   }
 
-  // When the binary name is not provided, support two use cases:
+  // When the binary name is not provided, support these use cases:
   // 1. There is only one binary uploaded to this release, a named binary.
-  // 2. There is an asset label matching the target triple (with no binary name).
+  // 2. There is an asset label matching the target triple or target duple.
   // In both cases, we assume that's the binary the user meant.
   // If there is ambiguity, exit with an error.
-  const matchingTargetTriples = releaseMetadata.data.assets.filter(
+  const matchingAssets = releaseMetadata.data.assets.filter(
     (asset) =>
-      typeof asset.label === "string" && asset.label.endsWith(targetTriple),
+      typeof asset.label === "string" &&
+      (asset.label.endsWith(targetTriple) || asset.label.endsWith(targetDuple)),
   );
-  if (matchingTargetTriples.length === 0) {
+  if (matchingAssets.length === 0) {
     throw new Error(
-      `Expected to find asset in release ${slug.owner}/${slug.repository}@${tag} with label ending in ${targetTriple}`,
+      `Expected to find asset in release ${slug.owner}/${slug.repository}@${tag} with label ending in ${targetTriple} or ${targetDuple}`,
     );
   }
-  if (matchingTargetTriples.length > 1) {
+  if (matchingAssets.length > 1) {
     throw new Error(
-      `Ambiguous targets: expected to find a single asset in release ${slug.owner}/${slug.repository}@${tag} matching target triple ${targetTriple}, but found ${matchingTargetTriples.length}.
+      `Ambiguous targets: expected to find a single asset in release ${slug.owner}/${slug.repository}@${tag} matching target triple ${targetTriple} or target duple ${targetDuple}, but found ${matchingAssets.length}.
 
 To resolve, specify the desired binary with the target format ${slug.owner}/${slug.repository}/<binary-name>@${tag}`,
     );
   }
-  const asset = matchingTargetTriples.shift()!;
+  const asset = matchingAssets.shift()!;
   const targetName = stripTargetTriple(asset.label!);
   return {
     binaryName: targetName,

src/fetch.ts

@@ -13,7 +13,7 @@ import {
   parseTargetReleases,
   parseToken,
 } from "./parse";
-import { getTargetTriple } from "./platform";
+import { getTargetTriple, getTargetDuple } from "./platform";
 import {
   fetchReleaseAssetMetadataFromTag,
   findExactSemanticVersionTag,
@@ -48,7 +48,10 @@ async function installGitHubReleaseBinary(
   token: string,
   ignoreExisting: boolean,
 ): Promise<void> {
-  const targetTriple = getTargetTriple(arch(), platform());
+  const currentArch = arch();
+  const currentPlatform = platform();
+  const targetTriple = getTargetTriple(currentArch, currentPlatform);
+  const targetDuple = getTargetDuple(currentArch, currentPlatform);
 
   const releaseTag = await findExactSemanticVersionTag(
     octokit,
@@ -60,8 +63,8 @@ async function installGitHubReleaseBinary(
     storageDirectory,
     targetRelease.slug,
     releaseTag,
-    platform(),
-    arch(),
+    currentPlatform,
+    currentArch,
   );
 
   const releaseAsset = await fetchReleaseAssetMetadataFromTag(
@@ -70,6 +73,7 @@ async function installGitHubReleaseBinary(
     targetRelease.binaryName,
     releaseTag,
     targetTriple,
+    targetDuple,
   );
 
   const destinationBasename = unwrapOrDefault(

src/index.ts

@@ -1,4 +1,4 @@
-import type { TargetTriple } from "./types";
+import type { TargetTriple, TargetDuple } from "./types";
 import { none, some, type Option } from "./option";
 
 const ALL_TARGET_TRIPLES: readonly TargetTriple[] = [
@@ -8,6 +8,14 @@ const ALL_TARGET_TRIPLES: readonly TargetTriple[] = [
   "x86_64-unknown-linux-musl",
 ] as unknown as readonly TargetTriple[];
 
+// Target duples (Go format OS-architecture combinations)
+export const TARGET_DUPLES: readonly TargetDuple[] = [
+  "-linux-amd64",
+  "-linux-arm64",
+  "-darwin-amd64",
+  "-darwin-arm64",
+] as unknown as readonly TargetDuple[];
+
 function architectureLabel(arch: string): string {
   switch (arch) {
     case "arm64":
@@ -54,16 +62,55 @@ export function getTargetTriple(
 }
 
 /**
- * String the string of its target triple suffix
+ * Get the target duple (e.g. "-linux-amd64") for the given architecture and platform
+ */
+export function getTargetDuple(
+  arch: string,
+  platform: NodeJS.Platform,
+): TargetDuple {
+  switch (platform) {
+    case "darwin":
+      return arch === "arm64" ? "-darwin-arm64" as TargetDuple : "-darwin-amd64" as TargetDuple;
+    case "linux":
+      return arch === "arm64" ? "-linux-arm64" as TargetDuple : "-linux-amd64" as TargetDuple;
+    default:
+      throw new Error(
+        `Unsupported platform ${platform} for target duple conversion`,
+      );
+  }
+}
+
+/**
+ * Strip the target triple or target duple suffix from a string
  */
 export function stripTargetTriple(value: string): Option<string> {
   // Can't strip away the target tuple if nothing else remains
   if (ALL_TARGET_TRIPLES.find((targetTriple) => targetTriple === value)) {
     return none();
   }
-  const stripped = ALL_TARGET_TRIPLES.reduce(
+
+  // Try to strip traditional target triple format first
+  const strippedTriple = ALL_TARGET_TRIPLES.reduce(
     (value, targetTriple) => value.replace(new RegExp(`-${targetTriple}$`), ""),
     value,
   );
-  return some(stripped);
+
+  // If the value changed, a target triple was found and stripped
+  if (strippedTriple !== value) {
+    return some(strippedTriple);
+  }
+
+  // Try to strip target duple suffix
+  const strippedDuple = TARGET_DUPLES.reduce(
+    (value, duple) => value.replace(new RegExp(`${duple}$`), ""),
+    value,
+  );
+
+  // If the value changed, a target duple was found and stripped
+  if (strippedDuple !== value) {
+    return some(strippedDuple);
+  }
+
+  // Nothing was stripped, return the original value
+  return some(value);
 }

src/platform.ts

@@ -32,6 +32,7 @@ export type RepositorySlug = {
 };
 
 export type TargetTriple = string & { readonly __tag: unique symbol };
+export type TargetDuple = string & { readonly __tag: unique symbol };
 export type BinaryName = string & { readonly __tag: unique symbol };
 
 export type TargetRelease = {