feat: add wildcard support to asset parameter in release utilities

Add support for simple glob patterns using a single wildcard (*) in asset parameters.
Users can now use intuitive patterns like 'yoga-sync-*.mjs' instead of { prefix: 'yoga-sync-', suffix: '.mjs' }.

Changes:
- Updated AssetPattern type to accept string patterns
- Added parseWildcardPattern() helper to convert wildcards to prefix/suffix
- Updated findReleaseAsset() to handle string patterns
- Updated socket-btm.ts to properly detect and handle wildcard vs exact strings
- Enhanced JSDoc with wildcard examples

Backward compatible: exact strings, object patterns, and RegExp still work.

Examples:
- 'yoga-sync-*.mjs' → matches any file starting with 'yoga-sync-' and ending with '.mjs'
- 'models-*.tar.gz' → matches any file starting with 'models-' and ending with '.tar.gz'
- '*-models.tar.gz' → matches any file ending with '-models.tar.gz'
- 'exact-name.txt' → exact match (no wildcard)

Author: jdalton

src/releases/github.ts

@@ -268,9 +268,18 @@ export function getAuthHeaders(): Record<string, string> {
 
 /**
  * Pattern for matching release assets.
- * Can be either a prefix/suffix pair or a RegExp.
+ * Can be either:
+ * - A string with wildcard (*) for simple glob patterns (e.g., 'yoga-sync-*.mjs')
+ * - A prefix/suffix pair for explicit matching
+ * - A RegExp for complex patterns
+ *
+ * String patterns support a single wildcard (*) which matches any characters:
+ * - 'yoga-sync-*.mjs' → prefix: 'yoga-sync-', suffix: '.mjs'
+ * - 'models-*.tar.gz' → prefix: 'models-', suffix: '.tar.gz'
+ * - '*-models.tar.gz' → prefix: '', suffix: '-models.tar.gz'
+ * - 'yoga-*' → prefix: 'yoga-', suffix: ''
  */
-export type AssetPattern = { prefix: string; suffix: string } | RegExp
+export type AssetPattern = string | { prefix: string; suffix: string } | RegExp
 
 /**
  * Result of finding a release asset.
@@ -282,30 +291,102 @@ export interface FindReleaseAssetResult {
   assetName: string
 }
 
+/**
+ * Parse a wildcard pattern string into prefix/suffix components.
+ * Supports a single wildcard (*) character.
+ *
+ * @param pattern - Pattern string with optional wildcard (e.g., 'yoga-sync-*.mjs')
+ * @returns Prefix/suffix pair for matching
+ * @throws Error if pattern contains multiple wildcards
+ *
+ * @example
+ * ```ts
+ * parseWildcardPattern('yoga-sync-*.mjs')
+ * // Returns: { prefix: 'yoga-sync-', suffix: '.mjs' }
+ *
+ * parseWildcardPattern('models-*.tar.gz')
+ * // Returns: { prefix: 'models-', suffix: '.tar.gz' }
+ *
+ * parseWildcardPattern('*-models.tar.gz')
+ * // Returns: { prefix: '', suffix: '-models.tar.gz' }
+ *
+ * parseWildcardPattern('yoga-*')
+ * // Returns: { prefix: 'yoga-', suffix: '' }
+ *
+ * parseWildcardPattern('exact-name.txt')
+ * // Returns: { prefix: 'exact-name.txt', suffix: '' } (exact match)
+ * ```
+ */
+function parseWildcardPattern(pattern: string): {
+  prefix: string
+  suffix: string
+} {
+  const wildcardIndex = pattern.indexOf('*')
+
+  // No wildcard - treat as exact match (prefix only).
+  if (wildcardIndex === -1) {
+    return { prefix: pattern, suffix: '' }
+  }
+
+  // Check for multiple wildcards.
+  const lastWildcardIndex = pattern.lastIndexOf('*')
+  if (wildcardIndex !== lastWildcardIndex) {
+    throw new Error(
+      `Pattern contains multiple wildcards: ${pattern}. Only single wildcard (*) is supported.`,
+    )
+  }
+
+  // Split at wildcard position.
+  const prefix = pattern.slice(0, wildcardIndex)
+  const suffix = pattern.slice(wildcardIndex + 1)
+
+  return { prefix, suffix }
+}
+
 /**
  * Find a release asset matching a pattern in the latest release.
  * Searches for the first release matching the tool prefix,
  * then finds the first asset matching the provided pattern.
  *
  * @param toolPrefix - Tool name prefix to search for (e.g., 'yoga-layout-')
- * @param assetPattern - Pattern to match asset names (prefix/suffix or RegExp)
+ * @param assetPattern - Pattern to match asset names (string with wildcard, prefix/suffix object, or RegExp)
  * @param repoConfig - Repository configuration (owner/repo)
  * @param options - Additional options
  * @returns Result with tag and asset name, or null if not found
  *
  * @example
  * ```ts
- * // Find yoga-sync asset with timestamped name
+ * // Find yoga-sync asset with wildcard pattern
  * const result = await findReleaseAsset(
  *   'yoga-layout-',
- *   { prefix: 'yoga-sync-', suffix: '.mjs' },
+ *   'yoga-sync-*.mjs',
  *   { owner: 'SocketDev', repo: 'socket-btm' }
  * )
  * // result = { tag: 'yoga-layout-2024-01-15-abc123', assetName: 'yoga-sync-2024-01-15-abc123.mjs' }
  * ```
  *
  * @example
  * ```ts
+ * // Find models tar.gz with wildcard pattern
+ * const result = await findReleaseAsset(
+ *   'models-',
+ *   'models-*.tar.gz',
+ *   { owner: 'SocketDev', repo: 'socket-btm' }
+ * )
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Find asset with object pattern (backward compatible)
+ * const result = await findReleaseAsset(
+ *   'yoga-layout-',
+ *   { prefix: 'yoga-sync-', suffix: '.mjs' },
+ *   { owner: 'SocketDev', repo: 'socket-btm' }
+ * )
+ * ```
+ *
+ * @example
+ * ```ts
  * // Find models tar.gz with regex
  * const result = await findReleaseAsset(
  *   'models-',
@@ -323,6 +404,14 @@ export async function findReleaseAsset(
   const { owner, repo } = repoConfig
   const { quiet = false } = options
 
+  // Normalize string patterns to prefix/suffix objects.
+  let normalizedPattern: { prefix: string; suffix: string } | RegExp
+  if (typeof assetPattern === 'string') {
+    normalizedPattern = parseWildcardPattern(assetPattern)
+  } else {
+    normalizedPattern = assetPattern
+  }
+
   return await pRetry(
     async () => {
       // Fetch recent releases (100 should cover all tool releases).
@@ -349,12 +438,12 @@ export async function findReleaseAsset(
         // Find matching asset in this release.
         let matchingAsset: { name: string } | undefined
 
-        if (assetPattern instanceof RegExp) {
+        if (normalizedPattern instanceof RegExp) {
           matchingAsset = assets.find((a: { name: string }) =>
-            assetPattern.test(a.name),
+            normalizedPattern.test(a.name),
           )
         } else {
-          const { prefix, suffix } = assetPattern
+          const { prefix, suffix } = normalizedPattern
           matchingAsset = assets.find(
             (a: { name: string }) =>
               a.name.startsWith(prefix) && a.name.endsWith(suffix),

src/releases/socket-btm.ts

@@ -59,7 +59,14 @@ export interface SocketBtmAssetConfig {
   downloadDir?: string
   /** Tool/package name for directory structure and release matching. */
   tool: string
-  /** Asset name or pattern on GitHub. Can be an exact name (string) or a pattern (prefix/suffix or RegExp). */
+  /**
+   * Asset name or pattern on GitHub.
+   * Can be:
+   * - A string with wildcard (*) for simple glob patterns (e.g., 'yoga-sync-*.mjs')
+   * - An exact asset name (string without wildcard)
+   * - A pattern object with prefix/suffix
+   * - A RegExp for complex patterns
+   */
   asset: string | AssetPattern
   /** Output filename. @default resolved asset name */
   output?: string
@@ -155,11 +162,14 @@ export async function downloadSocketBtmRelease(
     let resolvedAsset: string
     let resolvedTag = tag
 
-    if (typeof asset === 'string') {
+    // Check if asset is a string without wildcard (exact match).
+    const isExactMatch = typeof asset === 'string' && !asset.includes('*')
+
+    if (isExactMatch) {
       // Exact asset name provided.
-      resolvedAsset = asset
+      resolvedAsset = asset as string
     } else {
-      // Pattern provided - need to find matching asset.
+      // Pattern provided (wildcard string, object, or RegExp) - need to find matching asset.
       if (tag) {
         throw new Error(
           'Cannot use asset pattern with explicit tag. Either provide exact asset name or omit tag.',