feat: add retry and retry delay options for command execution

Author: jinghaihan

package.json

@@ -38,7 +38,7 @@
   "scripts": {
     "start": "tsx ./src/cli.ts",
     "build": "unbuild",
-    "typecheck": "tsc",
+    "typecheck": "tsc --noEmit",
     "test": "vitest",
     "lint": "eslint",
     "deps": "taze major -I",

src/cli.ts

@@ -1,20 +1,21 @@
 import type { CAC } from 'cac'
-import type { CommandOptions, MaybePromise, PublishOptions } from './types'
+import type { CommandOptions, PublishOptions } from './types'
 import { existsSync } from 'node:fs'
 import process from 'node:process'
 import c from 'ansis'
 import { cac } from 'cac'
 import { execa } from 'execa'
-import Spinner from 'yocto-spinner'
 import { name, version } from '../package.json'
 import { resolveConfig } from './config'
 import { PLATFORM_CHOICES } from './constants'
+import { executeWithFeedback } from './utils'
 
 try {
   const cli: CAC = cac('vsxpub')
 
   cli
     .command('')
+    .option('--cwd <dir>', 'Current working directory')
     .option('--repo <repo>', 'Github repo')
     .option('--tag <tag>', 'Github tag')
     .option('--name <name>', 'Extension name')
@@ -25,6 +26,8 @@ try {
     .option('--ovsx-pat <token>', 'Open Vsx Registry Token')
     .option('--include <platforms>', 'Include platforms from publishing (git, vsce, ovsx)', { default: PLATFORM_CHOICES })
     .option('--exclude <platforms>', 'Exclude platforms from publishing (git, vsce, ovsx)', { default: [] })
+    .option('--retry <count>', 'Retry count', { default: 3 })
+    .option('--retry-delay <ms>', 'Retry delay', { default: 1000 })
     .option('--dry', 'Dry run', { default: false })
     .allowUnknownOptions()
     .action(async (options: CommandOptions) => {
@@ -177,38 +180,3 @@ function normalizeArgs(args: string[], options: PublishOptions) {
 
   return args
 }
-
-async function executeWithFeedback(options: {
-  config: PublishOptions
-  message: string
-  successMessage: string
-  errorMessage: string
-  fn: () => MaybePromise<void>
-  dryFn?: () => MaybePromise<void>
-}): Promise<boolean> {
-  let result = false
-  const spinner = Spinner({ text: c.blue(options.message) }).start()
-
-  try {
-    if (options.config.dry) {
-      console.log()
-      await options.dryFn?.()
-    }
-    else {
-      await options.fn()
-    }
-
-    result = true
-    spinner.success(c.green(options.successMessage))
-  }
-  catch (error) {
-    spinner.error(c.red(options.errorMessage))
-    console.error(c.red(error instanceof Error ? error.message : String(error)))
-    result = false
-  }
-  finally {
-    console.log()
-  }
-
-  return result
-}

src/config.ts

@@ -1,5 +1,6 @@
 import type { CommandOptions, Platform, PublishOptions } from './types'
 import process from 'node:process'
+import c from 'ansis'
 import { createConfigLoader } from 'unconfig'
 import { DEFAULT_PUBLISH_OPTIONS } from './constants'
 import { getGitHubRepo, getGitTag, getVersionByGitTag, readTokenFromGitHubCli } from './git'
@@ -22,9 +23,7 @@ export async function resolveConfig(options: Partial<CommandOptions>): Promise<P
   const loader = createConfigLoader<CommandOptions>({
     sources: [
       {
-        files: [
-          'vsxpub.config',
-        ],
+        files: ['vsxpub.config'],
       },
     ],
     cwd,
@@ -59,5 +58,27 @@ export async function resolveConfig(options: Partial<CommandOptions>): Promise<P
 
   config.include = include.filter(p => !config.exclude.includes(p as Platform))
 
+  if (config.retry && typeof config.retry === 'string') {
+    const retry = Number(config.retry)
+    if (Number.isNaN(retry)) {
+      console.error(c.red('Invalid retry count'))
+      config.retry = 3
+    }
+    else {
+      config.retry = retry
+    }
+  }
+
+  if (config.retryDelay && typeof config.retryDelay === 'string') {
+    const retryDelay = Number(config.retryDelay)
+    if (Number.isNaN(retryDelay)) {
+      console.error(c.red('Invalid retry delay'))
+      config.retryDelay = 1000
+    }
+    else {
+      config.retryDelay = retryDelay
+    }
+  }
+
   return config as PublishOptions
 }

src/constants.ts

@@ -3,6 +3,8 @@ export const PLATFORM_CHOICES = ['git', 'vsce', 'ovsx'] as const
 export const DEFAULT_PUBLISH_OPTIONS = {
   baseUrl: 'github.com',
   baseUrlApi: 'api.github.com',
-  include: PLATFORM_CHOICES,
+  include: [...PLATFORM_CHOICES],
   exclude: [],
+  retry: 3,
+  retryDelay: 1000,
 }

src/types.ts

@@ -9,6 +9,16 @@ export interface CommonOptions {
   dry?: boolean
   include?: Platform[]
   exclude?: Platform[]
+  /**
+   * Retry count
+   * @default 3
+   */
+  retry?: number
+  /**
+   * Retry delay
+   * @default 1000ms
+   */
+  retryDelay?: number
 }
 
 export interface CommandOptions extends CommonOptions {

src/utils.ts

@@ -0,0 +1,59 @@
+/* eslint-disable no-console */
+import type { MaybePromise, PublishOptions } from './types'
+import c from 'ansis'
+import Spinner from 'yocto-spinner'
+
+export async function executeWithFeedback(options: {
+  config: PublishOptions
+  message: string
+  successMessage: string
+  errorMessage: string
+  fn: () => MaybePromise<void>
+  dryFn?: () => MaybePromise<void>
+}): Promise<boolean> {
+  let result = false
+  const spinner = Spinner({ text: c.blue(options.message) }).start()
+
+  const maxRetries = options.config.retry ?? 3
+  const retryDelay = options.config.retryDelay ?? 1000
+  let currentAttempt = 0
+
+  while (currentAttempt <= maxRetries) {
+    try {
+      if (currentAttempt > 0) {
+        console.log(c.yellow(`${options.message} (retry ${currentAttempt} of ${maxRetries})`))
+      }
+
+      if (options.config.dry) {
+        console.log()
+        await options.dryFn?.()
+      }
+      else {
+        await options.fn()
+      }
+
+      result = true
+      spinner.success(c.green(options.successMessage))
+      break
+    }
+    catch (error) {
+      currentAttempt++
+      console.error(c.red(error instanceof Error ? error.message : String(error)))
+
+      if (currentAttempt <= maxRetries) {
+        console.log(c.yellow(`Retrying in ${retryDelay}ms...`))
+        await new Promise(resolve => setTimeout(resolve, retryDelay))
+      }
+      else {
+        spinner.error(c.red(options.errorMessage))
+        if (maxRetries > 0) {
+          console.error(c.red(`Failed after ${maxRetries + 1} attempts`))
+        }
+        result = false
+      }
+    }
+  }
+
+  console.log()
+  return result
+}

test/cli.test.ts

@@ -0,0 +1,104 @@
+import type { PublishOptions } from '../src/types'
+import { describe, expect, it, vi } from 'vitest'
+import { DEFAULT_PUBLISH_OPTIONS } from '../src/constants'
+import { executeWithFeedback } from '../src/utils'
+
+const publisOptions: PublishOptions = {
+  ...DEFAULT_PUBLISH_OPTIONS,
+  cwd: '/test',
+  dry: false,
+  repo: 'test/repo',
+  tag: 'v1.0.0',
+  name: 'test-extension',
+  version: '1.0.0',
+  dependencies: true,
+  githubToken: 'token',
+  vscePat: 'vsce-pat',
+  ovsxPat: 'ovsx-pat',
+}
+
+describe('executeWithFeedback', () => {
+  it('should execute function successfully', async () => {
+    const mockFn = vi.fn().mockResolvedValue(undefined)
+
+    const result = await executeWithFeedback({
+      config: publisOptions,
+      message: 'Testing...',
+      successMessage: 'Success!',
+      errorMessage: 'Failed!',
+      fn: mockFn,
+    })
+
+    expect(result).toBe(true)
+    expect(mockFn).toHaveBeenCalledTimes(1)
+  })
+
+  it('should execute dryFn when in dry mode', async () => {
+    const mockFn = vi.fn()
+    const mockDryFn = vi.fn().mockResolvedValue(undefined)
+
+    const result = await executeWithFeedback({
+      config: { ...publisOptions, dry: true },
+      message: 'Testing...',
+      successMessage: 'Dry Run Success!',
+      errorMessage: 'Dry Run Failed!',
+      fn: mockFn,
+      dryFn: mockDryFn,
+    })
+
+    expect(result).toBe(true)
+    expect(mockFn).not.toHaveBeenCalled()
+    expect(mockDryFn).toHaveBeenCalledTimes(1)
+  })
+
+  it('should retry on failure', async () => {
+    const mockFn = vi.fn()
+      .mockRejectedValueOnce(new Error('First failure'))
+      .mockRejectedValueOnce(new Error('Second failure'))
+      .mockResolvedValueOnce(undefined)
+
+    const result = await executeWithFeedback({
+      config: { ...publisOptions, retry: 2, retryDelay: 10 },
+      message: 'Testing...',
+      successMessage: 'Success!',
+      errorMessage: 'Failed!',
+      fn: mockFn,
+    })
+
+    expect(result).toBe(true)
+    expect(mockFn).toHaveBeenCalledTimes(3)
+  })
+
+  it('should fail after exhausting retries', async () => {
+    const mockFn = vi.fn()
+      .mockRejectedValueOnce(new Error('First failure'))
+      .mockRejectedValueOnce(new Error('Second failure'))
+      .mockRejectedValueOnce(new Error('Third failure'))
+
+    const result = await executeWithFeedback({
+      config: { ...publisOptions, retry: 2, retryDelay: 10 },
+      message: 'Testing...',
+      successMessage: 'Success!',
+      errorMessage: 'Failed!',
+      fn: mockFn,
+    })
+
+    expect(result).toBe(false)
+    expect(mockFn).toHaveBeenCalledTimes(3)
+  })
+
+  it('should not retry when retryCount is not provided', async () => {
+    const mockFn = vi.fn().mockRejectedValue(new Error('Error'))
+
+    const result = await executeWithFeedback({
+      config: { ...publisOptions, retry: 0 },
+      message: 'Testing...',
+      successMessage: 'Success!',
+      errorMessage: 'Failed!',
+      fn: mockFn,
+    })
+
+    expect(result).toBe(false)
+    expect(mockFn).toHaveBeenCalledTimes(1)
+  })
+})