@nosto/nosto-cli 1.0.1

package/src/filesystem/processInBatches.ts

@@ -0,0 +1,38 @@
+import chalk from "chalk"
+
+import { getCachedConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+
+type Props = {
+  files: string[]
+  logIcon: string
+  processElement: (file: string) => Promise<unknown>
+}
+
+export async function processInBatches({ files, logIcon, processElement }: Props) {
+  const batchSize = getCachedConfig().maxRequests
+  const batches = []
+  let filesProcessed = 0
+  const totalFilesToPush = files.length
+  for (let i = 0; i < files.length; i += batchSize) {
+    batches.push(files.slice(i, i + batchSize))
+  }
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i]
+    const batchPromises = batch.map(async file => {
+      try {
+        await processElement(file)
+        filesProcessed += 1
+        Logger.info(`${chalk.green("✓")} [${filesProcessed}/${totalFilesToPush}] ${logIcon} ${chalk.cyan(file)}`)
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        Logger.error(`${chalk.red("✗")} ${chalk.cyan(file)}: ${errorMessage}`)
+      }
+    })
+    const results = await Promise.allSettled(batchPromises)
+    const failures = results.filter((result): result is PromiseRejectedResult => result.status === "rejected")
+    if (failures.length > 0) {
+      Logger.warn(`Batch completed with ${failures.length} failures`)
+    }
+  }
+}

package/src/filesystem/utils/getLoaderScript.ts

@@ -0,0 +1,28 @@
+export function getLoaderScript(): Uint8Array {
+  return new TextEncoder().encode(
+    `
+        (function() {
+            if (window.nostoTemplatesLoaded) {
+                return;
+            };
+            window.nostoTemplatesLoaded = true;
+
+            var u = window.nostoTemplatesFileResolver || function(v) {
+                return new URL(v, document.currentScript.src).toString();
+            };
+
+            var j = document.createElement('script');
+            j.type = 'text/javascript';
+            j.src = window.nostoTemplatesFileResolver('bundle.js');
+            document.body.appendChild(j);
+
+            var c = document.createElement('link');
+            c.rel = 'stylesheet';
+            c.type = 'text/css';
+            c.media = 'all';
+            c.href = window.nostoTemplatesFileResolver('bundle.css');
+            document.head.appendChild(c);
+        })();
+    `.replace(/\s+/g, " ")
+  )
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import { runCLI } from "#commander.ts"
+
+runCLI(process.argv)

package/src/modules/login.ts

@@ -0,0 +1,87 @@
+import http from "node:http"
+
+import open from "open"
+import z from "zod"
+
+import { AuthConfigFilePath } from "#config/authConfig.ts"
+import { getCachedConfig } from "#config/config.ts"
+import { AuthConfigSchema } from "#config/schema.ts"
+import { Logger } from "#console/logger.ts"
+import { InvalidLoginResponseError } from "#errors/InvalidLoginResponseError.ts"
+import { withErrorHandler } from "#errors/withErrorHandler.ts"
+import { writeFile } from "#filesystem/filesystem.ts"
+
+/**
+ * Playcart authentication flow works roughly as follows:
+ * - Internal web server is created by the CLI, listening on an ephemeral port
+ * - Browser page is opened to the Nosto login page with a redirect URI to localhost
+ * - After successful login (with 2FA), the redirect will hit the internal server
+ * - The response parameters are parsed from the query parameters
+ */
+export async function loginToPlaycart() {
+  const server = await createAuthServer()
+  const config = getCachedConfig()
+  const redirectUri = `http://localhost:${server.port}`
+  const adminUrl = config.apiUrl.replace("://api.", "://my.").replace("/api", "")
+  const loginUrl = `${adminUrl}/admin/cli/redirect?target=${encodeURIComponent(redirectUri)}`
+
+  await open(loginUrl)
+
+  Logger.info("Awaiting response from the browser...")
+  const response = await server.responseData
+  writeFile(AuthConfigFilePath, JSON.stringify(response, null, 2) + "\n")
+
+  Logger.success(`Login successful! Auth file saved at ${AuthConfigFilePath}`)
+}
+
+type AuthServer = {
+  port: number
+  responseData: Promise<PlaycartResponse>
+}
+
+type PlaycartResponse = z.infer<typeof AuthConfigSchema>
+
+/**
+ * The authentication server is created to handle a single redirect from the browser.
+ */
+async function createAuthServer(): Promise<AuthServer> {
+  const { promise: tokenPromise, resolve: resolveTokenPromise } = Promise.withResolvers<PlaycartResponse>()
+
+  function handleRequest(res: http.ServerResponse, req: http.IncomingMessage) {
+    res.writeHead(200, { "content-type": "text/plain", connection: "close" })
+    res.end("You can now close this page and return to the CLI.\n")
+
+    const url = new URL(req.url ?? "", "http://localhost")
+    const parsed = AuthConfigSchema.safeParse({
+      user: url.searchParams.get("user"),
+      token: url.searchParams.get("token"),
+      expiresAt: url.searchParams.get("expiresAt")
+    })
+    if (!parsed.success) {
+      throw new InvalidLoginResponseError(`Failed to parse playcart response: ${parsed.error.message}`)
+    }
+    resolveTokenPromise(parsed.data)
+  }
+
+  const server = http.createServer((req, res) => {
+    withErrorHandler(() => {
+      handleRequest(res, req)
+    })
+    server.close()
+  })
+
+  const port = await new Promise<number>(resolve => {
+    server.listen(0, "localhost", () => {
+      const addr = server.address()
+      if (!addr || typeof addr !== "object") {
+        throw new Error("Failed to get server address")
+      }
+      resolve(addr.port)
+    })
+  })
+
+  return {
+    port,
+    responseData: tokenPromise
+  }
+}

package/src/modules/logout.ts

@@ -0,0 +1,13 @@
+import fs from "fs"
+
+import { AuthConfigFilePath } from "#config/authConfig.ts"
+import { Logger } from "#console/logger.ts"
+
+export function removeLoginCredentials() {
+  Logger.info(`Deleting stored login credentials at ${AuthConfigFilePath}`)
+  if (!fs.existsSync(AuthConfigFilePath)) {
+    Logger.warn(`File already deleted.`)
+    return
+  }
+  fs.unlinkSync(AuthConfigFilePath)
+}

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

@@ -0,0 +1,61 @@
+import path from "node:path"
+
+import chalk from "chalk"
+
+import { getCachedConfig, getCachedSearchTemplatesConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+import { getBuildContext } from "#filesystem/esbuild.ts"
+import { isModernTemplateProject } from "#filesystem/legacyUtils.ts"
+import { loadLibrary } from "#filesystem/loadLibrary.ts"
+
+type Props = {
+  watch: boolean
+}
+
+export async function buildSearchTemplate({ watch }: Props) {
+  if (isModernTemplateProject()) {
+    await buildModernSearchTemplate({ watch })
+  } else {
+    await buildLegacySearchTemplate({ watch })
+  }
+}
+
+async function buildModernSearchTemplate({ watch }: Props) {
+  const { onBuild, onBuildWatch } = getCachedSearchTemplatesConfig()
+
+  if (watch) {
+    await onBuildWatch({
+      onAfterBuild: async () => {}
+    })
+  } else {
+    await onBuild()
+  }
+}
+
+async function buildLegacySearchTemplate({ watch }: Props) {
+  const { projectPath } = getCachedConfig()
+  const libraryPath = path.resolve(projectPath, ".nostocache/library")
+
+  Logger.info(`Fetching library to: ${chalk.cyan(libraryPath)}`)
+  await loadLibrary(libraryPath)
+
+  const targetPath = path.resolve(projectPath, "build")
+  Logger.info(`Building templates to: ${chalk.cyan(targetPath)}`)
+
+  const context = await getBuildContext()
+  if (!watch) {
+    await context.rebuild()
+    await context.dispose()
+    return
+  }
+
+  Logger.info(`Watching for changes. ${chalk.yellow("Press Ctrl+C to stop")}`)
+  await context.watch()
+
+  // Set up cleanup on process exit
+  process.on("SIGINT", () => {
+    context.dispose()
+    Logger.info(`${chalk.yellow("Watch mode stopped.")}`)
+    process.exit(0)
+  })
+}

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

@@ -0,0 +1,50 @@
+import chalk from "chalk"
+import path from "path"
+
+import { getCachedConfig, getCachedSearchTemplatesConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+import { getBuildContext } from "#filesystem/esbuild.ts"
+import { pushOnRebuildPlugin } from "#filesystem/esbuildPlugins.ts"
+import { isModernTemplateProject } from "#filesystem/legacyUtils.ts"
+import { loadLibrary } from "#filesystem/loadLibrary.ts"
+
+import { pushSearchTemplate } from "./push.ts"
+
+export async function searchTemplateDevMode() {
+  if (isModernTemplateProject()) {
+    await modernSearchTemplateDevMode()
+  } else {
+    await legacySearchTemplateDevMode()
+  }
+}
+
+async function modernSearchTemplateDevMode() {
+  const { onBuildWatch } = getCachedSearchTemplatesConfig()
+
+  Logger.info(`Starting dev mode. ${chalk.yellow("Press Ctrl+C to stop")}`)
+
+  await onBuildWatch({
+    onAfterBuild: async () => {
+      pushSearchTemplate({ paths: ["build"], force: false })
+    }
+  })
+}
+
+async function legacySearchTemplateDevMode() {
+  const { projectPath } = getCachedConfig()
+  const libraryPath = path.resolve(projectPath, ".nostocache/library")
+
+  Logger.info(`Fetching library to: ${chalk.cyan(libraryPath)}`)
+  await loadLibrary(libraryPath)
+
+  Logger.info(`Watching for changes. ${chalk.yellow("Press Ctrl+C to stop")}`)
+
+  const context = await getBuildContext({ plugins: [pushOnRebuildPlugin()] })
+  await context.watch()
+
+  process.on("SIGINT", () => {
+    context.dispose()
+    Logger.info(`${chalk.yellow("Watch mode stopped.")}`)
+    process.exit(0)
+  })
+}

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

@@ -0,0 +1,89 @@
+import chalk from "chalk"
+import fs from "fs"
+import path from "path"
+
+import { fetchWithRetry } from "#api/retry.ts"
+import { fetchSourceFile, fetchSourceFileIfExists } from "#api/source/fetchSourceFile.ts"
+import { listSourceFiles } from "#api/source/listSourceFiles.ts"
+import { getCachedConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+import { promptForConfirmation } from "#console/userPrompt.ts"
+import { calculateTreeHash } from "#filesystem/calculateTreeHash.ts"
+import { writeFile } from "#filesystem/filesystem.ts"
+import { processInBatches } from "#filesystem/processInBatches.ts"
+
+type PullSearchTemplateOptions = {
+  // Filter to only pull these files. Ignored if empty.
+  paths: string[]
+  // Skip checking the hash and pull all files.
+  force: boolean
+}
+
+/**
+ * Fetches the current templates to the specified target path.
+ * Processes files in parallel with controlled concurrency and retry logic.
+ */
+export async function pullSearchTemplate({ paths, force }: PullSearchTemplateOptions) {
+  const { projectPath, dryRun } = getCachedConfig()
+  const targetFolder = path.resolve(projectPath)
+
+  // If the local and remote hashes match, assume the content matches as well
+  const localHash = calculateTreeHash()
+  const remoteHash = await fetchSourceFileIfExists("build/hash")
+  if (localHash === remoteHash && !force) {
+    Logger.success("Local template is already up to date.")
+    writeFile(path.join(targetFolder, ".nostocache/hash"), localHash)
+    return
+  }
+
+  Logger.info(`Fetching templates to: ${chalk.cyan(targetFolder)}`)
+
+  // Fetch the remote file list (filtered by paths if provided)
+  const baseFiles = await listSourceFiles()
+  const files = baseFiles.filter(file => paths.length === 0 || paths.includes(file.path))
+  Logger.info(`Found ${chalk.cyan(files.length)} source files to fetch.`)
+
+  // Check for existing files that will be overridden
+  const filesToOverride = files.filter(file => {
+    const targetFilePath = path.join(targetFolder, file.path)
+    return fs.existsSync(targetFilePath)
+  })
+
+  // Just for safety, show a warning if the user is about to override files.
+  if (filesToOverride.length > 0 && !force) {
+    Logger.warn(`${chalk.cyan(filesToOverride.length)} files will be overridden:`)
+
+    // Show first 10 files that will be overridden
+    const previewFiles = filesToOverride.slice(0, 10)
+    previewFiles.forEach(file => {
+      Logger.warn(`${chalk.yellow("•")} ${chalk.cyan(file.path)}`)
+    })
+    if (filesToOverride.length > 10) {
+      Logger.warn(`${chalk.yellow("...")} and ${chalk.cyan(filesToOverride.length - 10)} more`)
+    }
+
+    // Ask for confirmation
+    const confirmed = await promptForConfirmation(`Are you sure you want to override your local data?`, "N")
+    if (!confirmed && !force) {
+      Logger.info("Operation cancelled by user")
+      return
+    }
+  }
+
+  // Pull the files into batches to avoid overwhelming the API (relevant mostly for local dev)
+  await processInBatches({
+    files: files.map(file => file.path),
+    logIcon: chalk.blue("↓"),
+    processElement: async filePath => {
+      const data = await fetchWithRetry(fetchSourceFile, filePath)
+      const pathToWrite = path.join(targetFolder, filePath)
+      writeFile(pathToWrite, data)
+    }
+  })
+
+  // Write the hash
+  if (!dryRun && fs.existsSync(path.join(targetFolder, "build/hash"))) {
+    fs.mkdirSync(path.join(targetFolder, ".nostocache"), { recursive: true })
+    fs.copyFileSync(path.join(targetFolder, "build/hash"), path.join(targetFolder, ".nostocache/hash"))
+  }
+}

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

@@ -0,0 +1,121 @@
+import chalk from "chalk"
+import fs from "fs"
+import path from "path"
+
+import { fetchSourceFileIfExists } from "#api/source/fetchSourceFile.ts"
+import { putSourceFile } from "#api/source/putSourceFile.ts"
+import { getCachedConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+import { promptForConfirmation } from "#console/userPrompt.ts"
+import { calculateTreeHash } from "#filesystem/calculateTreeHash.ts"
+import { listAllFiles, readFileIfExists, writeFile } from "#filesystem/filesystem.ts"
+import { processInBatches } from "#filesystem/processInBatches.ts"
+
+const MAX_RETRIES = 3
+const INITIAL_RETRY_DELAY = 1000 // 1 second
+
+type PushSearchTemplateOptions = {
+  // Filter to only push these files. Ignored if empty.
+  paths: string[]
+  // Skip checking the hash and push all files.
+  force: boolean
+}
+
+/**
+ * Deploys templates to the specified target path.
+ * Processes files in parallel with controlled concurrency and retry logic.
+ */
+export async function pushSearchTemplate({ paths, force }: PushSearchTemplateOptions) {
+  const { projectPath } = getCachedConfig()
+  const targetFolder = path.resolve(projectPath)
+
+  // List all files, excluding ignored and filtered by paths
+  const { allFiles, unfilteredFileCount } = listAllFiles(targetFolder)
+  const files = allFiles.filter(
+    file => paths.length === 0 || paths.includes(file) || paths.find(p => file.startsWith(p + "/"))
+  )
+
+  // Found literally no files -> nothing to do.
+  if (files.length === 0) {
+    Logger.warn("No files to push. Exiting.")
+    return
+  }
+
+  // If the local and remote hashes match, assume the content matches as well
+  const localHash = calculateTreeHash()
+  const remoteHash = await fetchSourceFileIfExists("build/hash")
+  if (localHash === remoteHash && !force) {
+    Logger.success("Remote template is already up to date.")
+    writeFile(path.join(targetFolder, ".nostocache/hash"), localHash)
+    return
+  }
+
+  /**
+   * If remote hash is present, we can check if there are conflicts. If not, just show the warning anyway.
+   * If remote hash doesn't match local hash, but remote hash matches last seen remote hash, then this is a clean push that shouldn't override anything.
+   * If .nostocache/hash is not present, it's a fresh checkout, but local state has changed already. Show the warning just in case.
+   * If remote hash doesn't match last seen remote hash, another user has pushed. Assume conflicts and show the warning.
+   */
+  const lastSeenRemoteHash = readFileIfExists(path.join(targetFolder, ".nostocache/hash"))
+  const shouldPrompt = !remoteHash || !lastSeenRemoteHash || remoteHash !== lastSeenRemoteHash
+  if (!force && shouldPrompt) {
+    let confirmationMessage = `It seems that the template has been changed since your last push. Are you sure you want to continue?`
+    if (!remoteHash || !lastSeenRemoteHash) {
+      confirmationMessage = `It seems that this is the first time you are pushing to this environment. Please make sure your local copy is up to date. Continue?`
+    }
+    const confirmed = await promptForConfirmation(confirmationMessage, "N")
+    if (!confirmed && !force) {
+      Logger.info("Push operation cancelled by user.")
+      return
+    }
+  }
+
+  Logger.info(`Pushing template from: ${chalk.cyan(targetFolder)}`)
+
+  // Update the hash files
+  writeFile(path.join(targetFolder, "build/hash"), localHash)
+  writeFile(path.join(targetFolder, ".nostocache/hash"), localHash)
+
+  // The hash file didn't exist, but now it does
+  if (!files.includes("build/hash")) {
+    files.push("build/hash")
+  }
+
+  // Collect some stats
+  const buildFileCount = files.filter(file => file.includes("build/")).length
+  const sourceFileCount = files.length - buildFileCount
+
+  const sourceFilesLabel = `${chalk.cyan(sourceFileCount)} source`
+  const builtFilesLabel = `${chalk.cyan(buildFileCount)} built`
+  const ignoredFilesLabel = `${chalk.cyan(unfilteredFileCount - files.length)} ignored`
+  Logger.info(
+    `Found ${chalk.cyan(files.length)} files to push (${sourceFilesLabel}, ${builtFilesLabel}, ${ignoredFilesLabel}).`
+  )
+
+  // Push the files in batches to avoid overwhelming the API (relevant mostly for local dev)
+  await processInBatches({
+    files,
+    logIcon: chalk.magenta("↑"),
+    processElement: async file => {
+      const filePath = path.join(targetFolder, file)
+      await putWithRetry(file, fs.readFileSync(filePath, "utf-8"))
+    }
+  })
+}
+
+async function putWithRetry(filePath: string, content: string, retryCount = 0): Promise<void> {
+  try {
+    return await putSourceFile(filePath, content)
+  } catch (error: unknown) {
+    if (retryCount >= MAX_RETRIES) {
+      const errorMessage = error instanceof Error ? error.message : String(error)
+      throw new Error(`Failed to push ${filePath} after ${MAX_RETRIES} retries: ${errorMessage}`)
+    }
+    const delay = INITIAL_RETRY_DELAY * Math.pow(2, retryCount)
+    Logger.warn(
+      `${chalk.yellow("⟳")} Failed to push ${chalk.cyan(filePath)}: Retrying in ${delay}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`
+    )
+    await new Promise(resolve => setTimeout(resolve, delay))
+    return putWithRetry(filePath, content, retryCount + 1)
+  }
+}

package/src/modules/setup.ts

@@ -0,0 +1,96 @@
+import chalk from "chalk"
+import fs from "fs"
+import path from "path"
+
+import { getDefaultConfig } from "#config/config.ts"
+import { EnvVariables, getEnvConfig } from "#config/envConfig.ts"
+import { Logger } from "#console/logger.ts"
+import { promptForConfirmation } from "#console/userPrompt.ts"
+import { writeFile } from "#filesystem/filesystem.ts"
+
+type Options = {
+  merchant?: string
+}
+
+export async function printSetupHelp(projectPath: string, options: Options) {
+  const defaultConfig = getDefaultConfig()
+
+  Logger.info(chalk.cyan(chalk.bold("Configuration Methods:")))
+  Logger.info(`  • Configuration file (${chalk.cyan(".nosto.json")} in project root)`)
+  Logger.info("  • Environment variables\n")
+
+  Logger.info(chalk.bold("Note: ") + "Environment variables take precedence over the configuration file.\n")
+
+  // Required parameters
+  Logger.info(chalk.bold("Merchant ID:"))
+  Logger.info(`  • Config file: ${chalk.cyan("merchant")}`)
+  Logger.info(`  • Env variable: ${chalk.magenta(EnvVariables.merchant)}`)
+  Logger.info(`  • Your merchant ID\n`)
+
+  // Optional parameters
+  Logger.info(chalk.yellow(chalk.bold("Optional Parameters:")))
+
+  Logger.info(chalk.bold("API Key:"))
+  Logger.info(`  • Config file: ${chalk.cyan("apiKey")}`)
+  Logger.info(`  • Env variable: ${chalk.magenta(EnvVariables.apiKey)}`)
+  Logger.info(`  • Your Nosto API key if needed. Used for CI or automation.\n`)
+
+  Logger.info(chalk.bold("Templates Environment:"))
+  Logger.info(`  • Config file: ${chalk.cyan("templatesEnv")}`)
+  Logger.info(`  • Env variable: ${chalk.magenta(EnvVariables.templatesEnv)}`)
+  Logger.info(`  • Nosto templates environment`)
+  Logger.info(`  • Default: ${chalk.green(defaultConfig.templatesEnv)}\n`)
+
+  Logger.info(chalk.bold("API URL:"))
+  Logger.info(`  • Config file: ${chalk.cyan("apiUrl")}`)
+  Logger.info(`  • Env variable: ${chalk.magenta(EnvVariables.apiUrl)}`)
+  Logger.info(`  • Nosto API URL`)
+  Logger.info(`  • Default: ${chalk.green(defaultConfig.apiUrl)}\n`)
+
+  Logger.info(chalk.bold("Log Level:"))
+  Logger.info(`  • Config file: ${chalk.cyan("logLevel")}`)
+  Logger.info(`  • Env variable: ${chalk.magenta(EnvVariables.logLevel)}`)
+  Logger.info(`  • Output log level`)
+  Logger.info(`  • Default: ${chalk.green(defaultConfig.logLevel)}\n`)
+
+  Logger.info(chalk.bold("Max Requests:"))
+  Logger.info(`  • Config file: ${chalk.cyan("maxRequests")}`)
+  Logger.info(`  • Env variable: ${chalk.magenta(EnvVariables.maxRequests)}`)
+  Logger.info(`  • Maximum number of requests in flight at the same time`)
+  Logger.info(`  • Default: ${chalk.green(defaultConfig.maxRequests)}\n`)
+
+  const configFilePath = path.join(projectPath, ".nosto.json")
+  if (fs.existsSync(configFilePath)) {
+    Logger.info(`Configuration file already exists at ${chalk.cyan(configFilePath)}`)
+    return
+  }
+
+  const envConfig = getEnvConfig()
+  const configToCreate = defaultConfig
+  Object.entries(envConfig).forEach(([key, value]) => {
+    if (key in configToCreate) {
+      Object.assign(configToCreate, { [key]: value })
+    }
+  })
+
+  const { merchant } = options
+  if (merchant) {
+    configToCreate.merchant = merchant
+  } else {
+    Logger.warn("Configuration file not found in project directory.")
+    Logger.info(chalk.greenBright("Preview:"))
+    Logger.info(chalk.dim("{"))
+    Object.entries(configToCreate).forEach(([key, value]) => {
+      Logger.info(chalk.dim(`  "${key}": "${value}",`))
+    })
+    Logger.info(chalk.dim("}"))
+  }
+
+  const confirmed = merchant || (await promptForConfirmation(`Would you like to create a configuration file?`, "Y"))
+  if (confirmed) {
+    writeFile(configFilePath, JSON.stringify(configToCreate, null, 2) + "\n")
+
+    const resolvedPath = path.resolve(configFilePath)
+    Logger.info(`Created configuration file in ${chalk.cyan(resolvedPath)}`)
+  }
+}

package/src/modules/status.ts

@@ -0,0 +1,71 @@
+import chalk from "chalk"
+
+import { getCachedConfig, loadConfig } from "#config/config.ts"
+import { Logger } from "#console/logger.ts"
+import { MissingConfigurationError } from "#errors/MissingConfigurationError.ts"
+
+export async function printStatus(projectPath: string) {
+  try {
+    await loadConfig({ projectPath, options: {} })
+  } catch (error) {
+    if (error instanceof MissingConfigurationError) {
+      Logger.error("Some required configuration is missing\n")
+    } else {
+      throw error
+    }
+  }
+  const { apiKey, apiUrl, logLevel, maxRequests, auth, merchant, templatesEnv } = getCachedConfig()
+  const { user, token, expiresAt } = auth
+
+  const notSet = chalk.redBright("Not set")
+  const formattedApiKey = apiKey ? chalk.greenBright(apiKey.slice(0, 6) + "[...]" + apiKey.slice(-4)) : notSet
+  const authToken = token ? chalk.greenBright(token.slice(0, 6) + "[...]" + token.slice(-4)) : notSet
+  const merchantId = merchant ? chalk.greenBright(merchant) : notSet
+
+  // Authentication
+  Logger.info(chalk.yellow("Authentication:"))
+  Logger.info(`  ${chalk.bold("User:")}          ${user ? chalk.cyan(user) : notSet}`)
+  Logger.info(`  ${chalk.bold("Token:")}         ${token ? authToken : notSet}`)
+  Logger.info(`  ${chalk.bold("Expires At:")}    ${expiresAt.getTime() > 0 ? chalk.cyan(expiresAt) : notSet}`)
+  Logger.info("")
+
+  // Required settings
+  Logger.info(chalk.yellow("Required Settings:"))
+  Logger.info(`  ${chalk.bold("Merchant ID:")}   ${merchantId}\n`)
+
+  // Optional settings
+  Logger.info(chalk.yellow("Optional Settings:"))
+  Logger.info(`  ${chalk.bold("API Key:")}       ${formattedApiKey}`)
+  Logger.info(`  ${chalk.bold("Templates Env:")} ${chalk.cyan(templatesEnv)}`)
+  Logger.info(`  ${chalk.bold("API URL:")}       ${chalk.cyan(apiUrl)}`)
+  Logger.info(`  ${chalk.bold("Log Level:")}     ${chalk.cyan(logLevel)}`)
+  Logger.info(`  ${chalk.bold("Max Requests:")}  ${chalk.cyan(maxRequests)}`)
+
+  Logger.info("")
+  const userAuthPresent = user && token && expiresAt.getTime() > 0
+  const userAuthValid = userAuthPresent && expiresAt.getTime() > Date.now()
+  const errors = []
+  if (!merchant) {
+    errors.push("Invalid configuration: Missing merchant ID")
+  }
+  if (!apiKey && !userAuthPresent) {
+    errors.push("Invalid configuration: Missing authentication (use `nosto login` or provide an API key)")
+  }
+  if (!apiKey && userAuthPresent && !userAuthValid) {
+    errors.push("Invalid configuration: Authentication token expired")
+  }
+
+  if (errors.length == 0) {
+    Logger.info(chalk.dim("Configuration seems to be valid:"))
+    if (apiKey) {
+      Logger.info(chalk.dim("  - Using API key for authentication"))
+    } else {
+      Logger.info(chalk.dim("  - Using user account for authentication"))
+    }
+  } else {
+    Logger.info(chalk.red("Configuration is not valid:"))
+    for (const error of errors) {
+      Logger.info(chalk.red("  - " + error))
+    }
+  }
+}