@nosto/nosto-cli 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosto/nosto-cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "main": "./src/index.ts",
   "bin": {
     "nosto": "./src/bootstrap.mjs"
@@ -29,12 +29,14 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.0.1",
     "chalk": "^5.6.2",
     "commander": "^14.0.1",
     "esbuild": "^0.27.0",
     "ignore": "^7.0.5",
     "ky": "^1.11.0",
-    "open": "^10.2.0",
+    "open": "^11.0.0",
+    "ora": "^9.0.0",
     "preact": "^10.27.2",
     "tsx": "^4.20.6",
     "zod": "^4.1.11"

package/src/api/deployments/createDeployment.ts

@@ -0,0 +1,12 @@
+import ky from "ky"
+
+import { getJsonHeaders, getSourceUrl } from "#api/utils.ts"
+
+export async function createDeployment({ path, description }: { path: string; description: string }) {
+  const url = getSourceUrl(`deployments/{env}/${path}`)
+
+  await ky.post(url, {
+    headers: getJsonHeaders(),
+    body: JSON.stringify({ description })
+  })
+}

package/src/api/deployments/listDeployments.ts

@@ -0,0 +1,12 @@
+import ky from "ky"
+
+import { getJsonHeaders, getSourceUrl } from "#api/utils.ts"
+
+import { ListDeploymentsSchema } from "./schema.ts"
+
+export async function listDeployments() {
+  const response = await ky.get(getSourceUrl("deployments/{env}"), {
+    headers: getJsonHeaders()
+  })
+  return ListDeploymentsSchema.parse(await response.json())
+}

package/src/api/deployments/rollbackDeployment.ts

@@ -0,0 +1,11 @@
+import ky from "ky"
+
+import { getJsonHeaders, getSourceUrl } from "#api/utils.ts"
+
+export async function rollbackDeployment() {
+  const url = getSourceUrl(`deployment/{env}`)
+
+  await ky.delete(url, {
+    headers: getJsonHeaders()
+  })
+}

package/src/api/deployments/schema.ts

@@ -0,0 +1,12 @@
+import z from "zod"
+
+export const ListDeploymentsSchema = z.array(
+  z.object({
+    id: z.string(),
+    created: z.number(),
+    active: z.boolean(),
+    latest: z.boolean(),
+    userId: z.string().optional(),
+    description: z.string().optional()
+  })
+)

package/src/api/deployments/updateDeployment.ts

@@ -0,0 +1,11 @@
+import ky from "ky"
+
+import { getJsonHeaders, getSourceUrl } from "#api/utils.ts"
+
+export async function updateDeployment(deploymentId: string) {
+  const url = getSourceUrl(`deployment/{env}/${deploymentId}`)
+
+  await ky.post(url, {
+    headers: getJsonHeaders()
+  })
+}

package/src/api/retry.ts

@@ -2,6 +2,7 @@ import chalk from "chalk"
 
 import { Logger } from "#console/logger.ts"
 
+import { createDeployment } from "./deployments/createDeployment.ts"
 import { putSourceFile } from "./source/putSourceFile.ts"
 
 const MAX_RETRIES = 3
@@ -42,3 +43,7 @@ export async function fetchWithRetry(
 export async function putWithRetry(filePath: string, content: string): Promise<void> {
   return executeWithRetry(() => putSourceFile(filePath, content), filePath, "push")
 }
+
+export async function deployWithRetry(path: string, description: string): Promise<void> {
+  return executeWithRetry(() => createDeployment({ path, description }), path, "push")
+}

package/src/commander.ts

@@ -3,6 +3,10 @@ import { Command } from "commander"
 import { loadConfig } from "#config/config.ts"
 import { Logger } from "#console/logger.ts"
 import { withErrorHandler } from "#errors/withErrorHandler.ts"
+import { deploymentsDeploy } from "#modules/deployments/deploy.ts"
+import { deploymentsList } from "#modules/deployments/list.ts"
+import { deploymentsRedeploy } from "#modules/deployments/redeploy.ts"
+import { deploymentsRollback } from "#modules/deployments/rollback.ts"
 import { loginToPlaycart } from "#modules/login.ts"
 import { removeLoginCredentials } from "#modules/logout.ts"
 import { buildSearchTemplate } from "#modules/search-templates/build.ts"
@@ -54,6 +58,61 @@ export async function runCLI(argv: string[]) {
       await withErrorHandler(() => printStatus(projectPath))
     })
 
+  const deployments = program.command("dp").alias("deployments").description("Deployments related commands")
+
+  deployments
+    .command("list [projectPath]")
+    .description("List all deployments for a project")
+    .option("--verbose", "set log level to debug")
+    .action(async (projectPath = ".", options) => {
+      await withSafeEnvironment({ projectPath, options, skipSanityCheck: true }, async () => {
+        await deploymentsList()
+      })
+    })
+
+  deployments
+    .command("deploy [projectPath]")
+    .description("Deploy a project")
+    .option("-d, --description <description>", "description for the deployment")
+    .option("--verbose", "set log level to debug")
+    .option("-f, --force", "skip confirmation prompt")
+    .action(async (projectPath = ".", options) => {
+      await withSafeEnvironment({ projectPath, options, skipSanityCheck: true }, async () => {
+        await deploymentsDeploy({
+          description: options.description,
+          force: options.force ?? false
+        })
+      })
+    })
+
+  deployments
+    .command("redeploy [projectPath]")
+    .description("Redeploy an existing deployment")
+    .option("-i, --id <deploymentId>", "deployment ID to redeploy (skips interactive selection)")
+    .option("--verbose", "set log level to debug")
+    .option("-f, --force", "skip confirmation prompt")
+    .action(async (projectPath = ".", options) => {
+      await withSafeEnvironment({ projectPath, options, skipSanityCheck: true }, async () => {
+        await deploymentsRedeploy({
+          deploymentId: options.id,
+          force: options.force ?? false
+        })
+      })
+    })
+
+  deployments
+    .command("disable [projectPath]")
+    .description("Disable the currently active deployment")
+    .option("--verbose", "set log level to debug")
+    .option("-f, --force", "skip confirmation prompt")
+    .action(async (projectPath = ".", options) => {
+      await withSafeEnvironment({ projectPath, options, skipSanityCheck: true }, async () => {
+        await deploymentsRollback({
+          force: options.force ?? false
+        })
+      })
+    })
+
   const searchTemplates = program
     .command("st")
     .alias("search-templates")
@@ -98,9 +157,10 @@ export async function runCLI(argv: string[]) {
     .option("--dry-run", "perform a dry run without making changes")
     .option("--verbose", "set log level to debug")
     .option("-w, --watch", "watch for changes and rebuild")
+    .option("-p, --push", "automatically push build artifacts after building")
     .action(async (projectPath = ".", options) => {
       await withSafeEnvironment({ projectPath, options }, async () => {
-        await buildSearchTemplate({ watch: options.watch ?? false })
+        await buildSearchTemplate({ watch: options.watch ?? false, push: options.push ?? false })
       })
     })
 

package/src/console/spinner.ts

@@ -0,0 +1,14 @@
+import ora from "ora"
+
+export async function withSpinner<T>(text: string, operation: () => Promise<T>) {
+  const spinner = ora(text).start()
+
+  try {
+    const result = await operation()
+    spinner.succeed()
+    return result
+  } catch (error) {
+    spinner.fail()
+    throw error
+  }
+}

package/src/console/userPrompt.ts

@@ -1,7 +1,7 @@
 import chalk from "chalk"
 import { createInterface } from "readline/promises"
 
-export async function promptForConfirmation(message: string, defaultAnswer: "Y" | "N"): Promise<boolean> {
+export async function promptForConfirmation(message: string, defaultAnswer: "Y" | "N") {
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout
@@ -14,3 +14,14 @@ export async function promptForConfirmation(message: string, defaultAnswer: "Y"
   const evaluatedAnswer = answer.length === 0 ? defaultAnswer : answer.toUpperCase()
   return evaluatedAnswer === "Y"
 }
+
+export async function promptForInput(message: string) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  const answer = await rl.question("\n" + message + " ")
+  rl.close()
+  return answer.trim()
+}

package/src/filesystem/homeDirectory.ts

@@ -1,3 +1,6 @@
 import os from "os"
 
-export const HomeDirectory = import.meta.env.MODE === "test" ? "/vitest/home" : os.homedir()
+/**
+ * `import.meta.env` is NOT defined in production builds
+ */
+export const HomeDirectory = import.meta.env?.MODE === "test" ? "/vitest/home" : os.homedir()

package/src/modules/deployments/deploy.ts

@@ -0,0 +1,80 @@
+import chalk from "chalk"
+import path from "path"
+
+import { deployWithRetry } from "#api/retry.ts"
+import { fetchSourceFileIfExists } from "#api/source/fetchSourceFile.ts"
+import { getCachedConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+import { withSpinner } from "#console/spinner.ts"
+import { promptForConfirmation, promptForInput } from "#console/userPrompt.ts"
+import { calculateTreeHash } from "#filesystem/calculateTreeHash.ts"
+import { readFileIfExists, writeFile } from "#filesystem/filesystem.ts"
+import { isValidAlphaNumeric } from "#utils/validations.ts"
+
+type DeployOptions = {
+  description?: string
+  force: boolean
+}
+
+export async function deploymentsDeploy({ description, force }: DeployOptions) {
+  const { projectPath } = getCachedConfig()
+
+  const localHash = calculateTreeHash()
+  const remoteHash = await fetchSourceFileIfExists("build/hash")
+  const lastSeenRemoteHash = readFileIfExists(path.join(projectPath, ".nostocache/hash"))
+
+  if (!remoteHash) {
+    Logger.error("No files found in remote. Please run 'st build --push' first to push your build.")
+    return
+  }
+
+  if (!force) {
+    if (localHash !== remoteHash) {
+      Logger.warn("Local files don't match remote.")
+      Logger.warn(`You may need to run ${chalk.cyan("st push")} first to push your changes.`)
+      const confirmed = await promptForConfirmation("Continue with deployment anyway?", "N")
+      if (!confirmed) {
+        Logger.info("Deployment cancelled by user.")
+        return
+      }
+    }
+
+    if (lastSeenRemoteHash !== remoteHash) {
+      Logger.warn("Remote files have changed since your last sync.")
+      const confirmed = await promptForConfirmation("Continue with deployment?", "N")
+      if (!confirmed) {
+        Logger.info("Deployment cancelled by user.")
+        return
+      }
+    }
+  }
+
+  const deploymentDescription = description || (await promptForInput("Enter a description for this deployment:"))
+
+  if (!isValidAlphaNumeric(deploymentDescription)) {
+    Logger.error("Description must be alphanumeric and between 1 and 200 characters.")
+    return
+  }
+
+  if (!force) {
+    const confirmed = await promptForConfirmation(
+      `You are about to create a deployment with description: ${chalk.cyan(`"${deploymentDescription}"`)}. Continue?`,
+      "N"
+    )
+    if (!confirmed) {
+      Logger.info("Deployment cancelled by user.")
+      return
+    }
+  }
+
+  Logger.info("Creating deployment from remote 'build' path...")
+  Logger.info(`Description: ${chalk.cyan(`"${deploymentDescription}"`)}`)
+
+  await withSpinner("Creating deployment...", async () => {
+    await deployWithRetry("build", deploymentDescription)
+  })
+
+  Logger.success("Deployment created successfully!")
+
+  writeFile(path.join(projectPath, ".nostocache/hash"), remoteHash)
+}

package/src/modules/deployments/list.ts

@@ -0,0 +1,41 @@
+import chalk from "chalk"
+
+import { listDeployments } from "#api/deployments/listDeployments.ts"
+import { Logger } from "#console/logger.ts"
+import { withSpinner } from "#console/spinner.ts"
+import { formatDate } from "#utils/formatDate.ts"
+
+export async function deploymentsList() {
+  const deployments = await withSpinner("Collecting deployment data...", async () => {
+    return await listDeployments()
+  })
+
+  if (!deployments || deployments.length === 0) {
+    Logger.info(chalk.yellow("No deployments found"))
+    return
+  }
+
+  Logger.info(chalk.bold(`Found ${deployments.length} deployment(s):`))
+
+  deployments.forEach((deployment, index) => {
+    const statusBadge = deployment.active ? chalk.green("Active") : chalk.red("Inactive")
+    const latestBadge = deployment.latest ? chalk.greenBright("[LATEST] ") : ""
+    const createdDate = formatDate(deployment.created)
+    const bulletin = deployment.active ? chalk.bgGreenBright("  ") : "  "
+    Logger.info(`${bulletin} ${latestBadge}${chalk.blueBright(`ID: ${deployment.id}`)}`)
+    Logger.info(`   ${chalk.bold("Status:")}      ${statusBadge}`)
+    Logger.info(`   ${chalk.bold("Created At:")}  ${chalk.cyan(createdDate)}`)
+
+    if (deployment.userId) {
+      Logger.info(`   ${chalk.bold("User:")}        ${chalk.cyan(deployment.userId)}`)
+    }
+
+    if (deployment.description) {
+      Logger.info(`   ${chalk.bold("Description:")} ${deployment.description}`)
+    }
+
+    if (index < deployments.length - 1) {
+      Logger.info("")
+    }
+  })
+}

package/src/modules/deployments/redeploy.ts

@@ -0,0 +1,103 @@
+import { select } from "@inquirer/prompts"
+import chalk from "chalk"
+
+import { listDeployments } from "#api/deployments/listDeployments.ts"
+import { updateDeployment } from "#api/deployments/updateDeployment.ts"
+import { Logger } from "#console/logger.ts"
+import { withSpinner } from "#console/spinner.ts"
+import { promptForConfirmation } from "#console/userPrompt.ts"
+import { formatDate } from "#utils/formatDate.ts"
+
+type RedeployOptions = {
+  deploymentId?: string
+  force: boolean
+}
+
+export async function deploymentsRedeploy({ deploymentId, force }: RedeployOptions) {
+  let selectedDeployment = null
+  let selectedDeploymentId
+
+  if (deploymentId) {
+    selectedDeploymentId = deploymentId
+    const deployments = await withSpinner("Collecting deployment data...", async () => {
+      return await listDeployments()
+    })
+    selectedDeployment = deployments.find(d => d.id === deploymentId) || null
+
+    if (!selectedDeployment) {
+      Logger.error(`Deployment with ID "${selectedDeploymentId}" not found.`)
+      return
+    }
+  } else {
+    const result = await selectDeploymentInteractively("Select a deployment to redeploy:")
+
+    if (!result) {
+      Logger.error("No deployment selected. Aborting.")
+      return
+    }
+
+    selectedDeploymentId = result.id
+    selectedDeployment = result.deployment
+  }
+
+  Logger.info(`Selected deployment: ${chalk.cyan(selectedDeployment.id)}`)
+  if (selectedDeployment.description) {
+    Logger.info(`Description: ${selectedDeployment.description}`)
+  }
+
+  if (!force) {
+    const confirmed = await promptForConfirmation(
+      `Are you sure you want to redeploy version ${chalk.cyan(selectedDeploymentId)}?`,
+      "N"
+    )
+    if (!confirmed) {
+      Logger.info("Redeployment cancelled by user.")
+      return
+    }
+  }
+
+  await withSpinner(`Redeploying version ${chalk.cyan(selectedDeploymentId)}...`, async () => {
+    await updateDeployment(selectedDeploymentId)
+  })
+
+  Logger.success("Redeployed successfully!")
+}
+
+export async function selectDeploymentInteractively(message: string) {
+  const deployments = await withSpinner("Collecting deployment data...", async () => {
+    return await listDeployments()
+  })
+
+  if (!deployments || deployments.length === 0) {
+    Logger.error("No deployments found.")
+    return null
+  }
+
+  Logger.info(chalk.gray(`${chalk.bgGreenBright("  ")} = Currently active deployment\n`))
+
+  const choices = deployments.map(deployment => {
+    const createdDate = formatDate(deployment.created)
+    const statusBadge = deployment.active ? chalk.bgGreenBright("  ") : "  "
+    const description = deployment.description ? ` - ${deployment.description}` : ""
+    const idColor = deployment.active ? chalk.green : chalk.blueBright
+
+    return {
+      name: `${statusBadge} [${idColor(createdDate)}] ${idColor(deployment.id)}${description}`,
+      value: deployment.id,
+      description: deployment.description || "No description"
+    }
+  })
+
+  const selectedId = await select({
+    message,
+    choices,
+    pageSize: 10
+  })
+
+  if (!selectedId) {
+    return null
+  }
+
+  const selectedDeployment = deployments.find(d => d.id === selectedId)
+  return selectedDeployment ? { id: selectedId, deployment: selectedDeployment } : null
+}

package/src/modules/deployments/rollback.ts

@@ -0,0 +1,29 @@
+import { rollbackDeployment } from "#api/deployments/rollbackDeployment.ts"
+import { Logger } from "#console/logger.ts"
+import { withSpinner } from "#console/spinner.ts"
+import { promptForConfirmation } from "#console/userPrompt.ts"
+
+type RollbackOptions = {
+  force: boolean
+}
+
+export async function deploymentsRollback({ force }: RollbackOptions) {
+  if (!force) {
+    const confirmed = await promptForConfirmation(
+      `Are you sure you want to disable the currently active deployment?`,
+      "N"
+    )
+    if (!confirmed) {
+      Logger.info("Operation cancelled by user.")
+      return
+    }
+  }
+
+  Logger.info("Disabling active deployment...")
+
+  await withSpinner("Disabling active deployment...", async () => {
+    await rollbackDeployment()
+  })
+
+  Logger.success("Active deployment disabled successfully!")
+}

package/src/modules/search-templates/build.ts

@@ -8,19 +8,22 @@ import { getBuildContext } from "#filesystem/esbuild.ts"
 import { isModernTemplateProject } from "#filesystem/legacyUtils.ts"
 import { loadLibrary } from "#filesystem/loadLibrary.ts"
 
+import { pushSearchTemplate } from "./push.ts"
+
 type Props = {
   watch: boolean
+  push?: boolean
 }
 
-export async function buildSearchTemplate({ watch }: Props) {
+export async function buildSearchTemplate({ watch, push = false }: Props) {
   if (isModernTemplateProject()) {
-    await buildModernSearchTemplate({ watch })
+    await buildModernSearchTemplate({ watch, push })
   } else {
-    await buildLegacySearchTemplate({ watch })
+    await buildLegacySearchTemplate({ watch, push })
   }
 }
 
-async function buildModernSearchTemplate({ watch }: Props) {
+async function buildModernSearchTemplate({ watch, push }: Props) {
   const { onBuild, onBuildWatch } = getCachedSearchTemplatesConfig()
 
   if (watch) {
@@ -30,9 +33,14 @@ async function buildModernSearchTemplate({ watch }: Props) {
   } else {
     await onBuild()
   }
+
+  if (push && !watch) {
+    Logger.info("")
+    await pushSearchTemplate({ paths: ["build"], force: false })
+  }
 }
 
-async function buildLegacySearchTemplate({ watch }: Props) {
+async function buildLegacySearchTemplate({ watch, push }: Props) {
   const { projectPath } = getCachedConfig()
   const libraryPath = path.resolve(projectPath, ".nostocache/library")
 
@@ -46,6 +54,11 @@ async function buildLegacySearchTemplate({ watch }: Props) {
   if (!watch) {
     await context.rebuild()
     await context.dispose()
+
+    if (push) {
+      Logger.info("")
+      await pushSearchTemplate({ paths: ["build"], force: false })
+    }
     return
   }
 

package/src/utils/formatDate.ts

@@ -0,0 +1,17 @@
+/**
+ * Formats a date as YYYY-MM-DD HH:mm in UTC
+ * @param date - Date to format (timestamp in milliseconds or Date object)
+ * @returns Formatted date string in UTC (e.g., "2025-10-10 17:33")
+ * @note Always uses UTC to ensure consistent display across timezones
+ */
+export function formatDate(date: number | Date): string {
+  const d = typeof date === "number" ? new Date(date) : date
+
+  const year = d.getUTCFullYear()
+  const month = String(d.getUTCMonth() + 1).padStart(2, "0")
+  const day = String(d.getUTCDate()).padStart(2, "0")
+  const hours = String(d.getUTCHours()).padStart(2, "0")
+  const minutes = String(d.getUTCMinutes()).padStart(2, "0")
+
+  return `${year}-${month}-${day} ${hours}:${minutes}`
+}

package/src/utils/validations.ts

@@ -0,0 +1,8 @@
+export function isValidAlphaNumeric(input: unknown) {
+  if (typeof input !== "string") {
+    return false
+  }
+  const regex = /^[A-Za-z0-9 \-_.!,?]{1,200}$/
+
+  return regex.test(input)
+}

package/test/commander.test.ts

@@ -147,7 +147,7 @@ describe("commander", () => {
 
       it("should call the function", async () => {
         await commander.run("nosto st build")
-        expect(buildSpy).toHaveBeenCalledWith({ watch: false })
+        expect(buildSpy).toHaveBeenCalledWith({ watch: false, push: false })
       })
 
       it("should rethrow errors", async () => {

package/test/console/spinner.test.ts

@@ -0,0 +1,55 @@
+import ora from "ora"
+import { describe, expect, it, vi } from "vitest"
+
+import { withSpinner } from "#console/spinner.ts"
+import { setupMockConsole } from "#test/utils/mockConsole.ts"
+
+const terminal = setupMockConsole()
+
+describe("withSpinner", () => {
+  it("should start spinner, execute operation, and succeed", async () => {
+    const operation = vi.fn().mockResolvedValue("success")
+
+    const result = await withSpinner("Loading...", operation)
+
+    expect(ora).toHaveBeenCalledWith("Loading...")
+    expect(terminal.getSpinnerSpy("start")).toHaveBeenCalled()
+    expect(operation).toHaveBeenCalled()
+    expect(terminal.getSpinnerSpy("succeed")).toHaveBeenCalled()
+    expect(terminal.getSpinnerSpy("fail")).not.toHaveBeenCalled()
+    expect(result).toBe("success")
+  })
+
+  it("should start spinner, handle error, and fail", async () => {
+    const error = new Error("API failed")
+    const operation = vi.fn().mockRejectedValue(error)
+
+    await expect(withSpinner("Loading...", operation)).rejects.toThrow("API failed")
+
+    expect(ora).toHaveBeenCalledWith("Loading...")
+    expect(terminal.getSpinnerSpy("start")).toHaveBeenCalled()
+    expect(operation).toHaveBeenCalled()
+    expect(terminal.getSpinnerSpy("fail")).toHaveBeenCalled()
+    expect(terminal.getSpinnerSpy("succeed")).not.toHaveBeenCalled()
+  })
+
+  it("should return the operation result", async () => {
+    const expectedData = { id: 1, name: "test" }
+    const operation = vi.fn().mockResolvedValue(expectedData)
+
+    const result = await withSpinner("Fetching data...", operation)
+
+    expect(result).toEqual(expectedData)
+  })
+
+  it("should handle synchronous errors", async () => {
+    const operation = vi.fn().mockImplementation(() => {
+      throw new Error("Sync error")
+    })
+
+    await expect(withSpinner("Loading...", operation)).rejects.toThrow("Sync error")
+
+    expect(terminal.getSpinnerSpy("fail")).toHaveBeenCalled()
+    expect(terminal.getSpinnerSpy("succeed")).not.toHaveBeenCalled()
+  })
+})

package/test/setup.ts

@@ -3,7 +3,7 @@ import { beforeEach } from "vitest"
 import { vi } from "vitest"
 
 import { mockHttpServer } from "./utils/mockAuthServer.ts"
-import { mockedConsoleIn, mockedConsoleOut } from "./utils/mockConsole.ts"
+import { mockedConsoleIn, mockedConsoleOut, mockedSpinner } from "./utils/mockConsole.ts"
 
 export const testVolume = Volume.fromJSON({}, "/")
 
@@ -37,3 +37,9 @@ vi.mock("open", () => {
 vi.mock("node:http", () => ({
   default: mockHttpServer
 }))
+
+vi.mock("ora", () => {
+  return {
+    default: vi.fn(() => mockedSpinner)
+  }
+})

package/test/utils/mockConsole.ts

@@ -28,9 +28,27 @@ export const mockedConsoleOut = {
   }
 }
 
+export const mockedSpinner = {
+  start: vi.fn(function (this: typeof mockedSpinner) {
+    return this
+  }),
+  stop: vi.fn(function (this: typeof mockedSpinner) {
+    return this
+  }),
+  succeed: vi.fn(function (this: typeof mockedSpinner) {
+    return this
+  }),
+  fail: vi.fn(function (this: typeof mockedSpinner) {
+    return this
+  }),
+  text: ""
+}
+
 export function setupMockConsole() {
   afterEach(() => {
     mockedConsoleIn.recordedPrompts = []
+    mockedSpinner.text = ""
+    vi.clearAllMocks()
   })
 
   return {
@@ -58,10 +76,18 @@ export function setupMockConsole() {
         merchantId: "",
         isDryRun: false
       }
+      mockedSpinner.start.mockClear()
+      mockedSpinner.stop.mockClear()
+      mockedSpinner.succeed.mockClear()
+      mockedSpinner.fail.mockClear()
+      mockedSpinner.text = ""
     },
     getSpy: (method: Exclude<keyof typeof mockedConsoleOut.Logger, "context">) => {
       return mockedConsoleOut.Logger[method]
     },
+    getSpinnerSpy: (method: keyof typeof mockedSpinner) => {
+      return mockedSpinner[method]
+    },
     expect: {
       user: {
         toHaveBeenPromptedWith: (prompt: string) => {