@by-association-only/theme-backup 1.0.0

package/.nvmrc

@@ -0,0 +1 @@
+18

package/README.md

@@ -0,0 +1,92 @@
+# Theme Backup
+
+A CLI tool to backup Shopify themes across multiple stores.
+
+## What it does
+
+This tool helps you create backups of Shopify themes across multiple stores in your organization:
+
+- Reads store URLs from a config file (`.bao-stores` or `.bao-translation-checker`)
+- Shows interactive theme selection UI
+- Checks theme limits and prompts for deletion if needed:
+  - At 100 themes: Forces deletion (must delete at least 1)
+  - Above 20 themes: Optional deletion prompt
+- Backs up selected theme with naming: `[Original Name] (Backup YYYY-MM-DD)`
+- Uses Shopify CLI `pull` and `push` commands for duplication
+
+## Setup
+
+1) Install the package:
+
+```bash
+npm i @by-association-only/theme-backup --save-dev
+```
+
+or
+
+```bash
+yarn add @by-association-only/theme-backup --save-dev
+```
+
+2) Add a config file in the root: `.bao-stores` (or use existing `.bao-translation-checker`)
+
+List each store name on a separate line (the part before .myshopify.com).
+
+Example:
+If your stores are:
+- acmestore.myshopify.com
+- acmestore-us.myshopify.com
+
+You would enter:
+```
+acmestore
+acmestore-us
+```
+
+3) Run the backup tool:
+
+```bash
+bao-theme-backup
+```
+
+## Usage
+
+The tool will:
+1. Process each store in your config file
+2. Check theme count and prompt for deletion if needed
+3. Show interactive theme selector
+4. Pull the selected theme to a temp folder
+  5. Push it as a new unpublished theme with backup naming using the DD/MM/YYYY format
+6. Clean up temp files
+
+## Theme Limit Handling
+
+The tool automatically checks your theme count and handles it as follows:
+
+- **100+ themes**: You've hit the maximum limit. The tool will force you to delete at least 1 theme before proceeding with the backup.
+- **21-99 themes**: You'll see a prompt: "You have X themes currently. Would you like to delete any?" You can choose to delete some themes or skip and proceed directly to backup.
+- **20 or fewer themes**: The tool proceeds directly to theme selection and backup.
+
+**Note**: Shopify's theme limits are:
+- Non-Plus stores: 20 themes maximum
+- Shopify Plus stores: 100 themes maximum
+
+## Requirements
+
+- Node v18.20+
+- Shopify CLI v3.71+
+- Valid Shopify store access
+
+## Issues
+
+### Authentication Required
+
+If you see authentication errors, make sure you're logged into Shopify CLI:
+
+```bash
+shopify auth login
+```
+
+### Theme Limit Errors
+
+If you're at the theme limit, the tool will prompt you to delete themes before proceeding.

package/index.js

@@ -0,0 +1,582 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+import path from 'node:path'
+import chalk from 'chalk'
+import { execSync } from 'node:child_process'
+
+// Function to read stores from config file
+function readStoresFromConfig() {
+  try {
+    // Check for .bao-stores first, fallback to .bao-translation-checker
+    const baoStoresPath = path.join(process.cwd(), '.bao-stores')
+    const legacyPath = path.join(process.cwd(), '.bao-translation-checker')
+
+    let configPath
+    if (fs.existsSync(baoStoresPath)) {
+      configPath = baoStoresPath
+    } else if (fs.existsSync(legacyPath)) {
+      configPath = legacyPath
+    } else {
+      console.error(chalk.red('Error: Config file not found.'))
+      console.error(chalk.gray('Create a .bao-stores or .bao-translation-checker file in your project root with one store URL per line.'))
+      process.exit(1)
+    }
+
+    const content = fs.readFileSync(configPath, 'utf8')
+    const stores = content.split('\n').filter(line => line.trim())
+    if (stores.length === 0) {
+      throw new Error('No stores found in config file')
+    }
+    return stores
+  } catch (error) {
+    console.error(chalk.red('Error reading config file:'))
+    console.error(chalk.red(error.message))
+    process.exit(1)
+  }
+}
+
+// Function to get list of themes from a store
+async function getStoreThemes(store) {
+  try {
+    console.log(chalk.gray(`  Fetching themes from ${store}...`))
+    const output = execSync(`shopify theme list -s=${store} --json`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'] // Silent mode since auth is already handled
+    })
+    return JSON.parse(output)
+  } catch (error) {
+    console.error(chalk.red(`Failed to fetch themes for ${store}:`))
+    console.error(chalk.red(error.message))
+    return null
+  }
+}
+
+// Function to filter themes based on search input
+function filterThemes(themes, searchTerm) {
+  if (!searchTerm) return themes
+  const term = searchTerm.toLowerCase()
+  return themes.filter(theme =>
+    theme.name.toLowerCase().includes(term) ||
+    theme.id.toString().includes(term)
+  )
+}
+
+// Function to handle theme selection
+async function selectTheme(store, actionText = 'Please select theme to backup') {
+  const themes = await getStoreThemes(store)
+  if (!themes || themes.length === 0) {
+    console.error(chalk.red('No themes found for this store'))
+    return null
+  }
+
+  let filteredThemes = themes
+  let currentPage = 1
+  const pageSize = 10
+  let selectedIndex = 0
+  let searchTerm = ''
+
+  // Enable raw mode for real-time input
+  process.stdin.setRawMode(true)
+  process.stdin.resume()
+
+  const clearScreen = () => {
+    process.stdout.write('\x1B[2J\x1B[H')
+  }
+
+  // Helper to get sorted themes
+  const getSortedThemes = () => {
+    return [...filteredThemes].sort((a, b) => {
+      if (a.role === 'live') return -1
+      if (b.role === 'live') return 1
+      return 0
+    })
+  }
+
+  const updateDisplay = () => {
+    clearScreen()
+    console.log(chalk.bold(`\n${store} - ${actionText}:`))
+    console.log(chalk.bold('----------------------------------------'))
+
+    // Sort themes to put published theme first
+    const sortedThemes = getSortedThemes()
+
+    const start = (currentPage - 1) * pageSize
+    const end = start + pageSize
+    const pageThemes = sortedThemes.slice(start, end)
+
+    let hasShownLiveTheme = false
+
+    pageThemes.forEach((theme, index) => {
+      const isLive = theme.role === 'live'
+      const isSelected = start + index === selectedIndex
+      const line = `${theme.name} (ID: ${theme.id})`
+
+      // Add blank line after live theme if we haven't shown it yet
+      if (!hasShownLiveTheme && !isLive && sortedThemes.some(t => t.role === 'live')) {
+        console.log('')
+        hasShownLiveTheme = true
+      }
+
+      if (isLive) {
+        console.log(isSelected ?
+          chalk.bgCyan.black(`[LIVE THEME] ${line}`) :
+          chalk.green(`[LIVE THEME] ${line}`)
+        )
+      } else {
+        console.log(isSelected ?
+          chalk.bgCyan.black(line) :
+          chalk.cyan(line)
+        )
+      }
+    })
+
+    if (filteredThemes.length > pageSize) {
+      const totalPages = Math.ceil(filteredThemes.length / pageSize)
+      console.log(chalk.gray(`\nPage ${currentPage} of ${totalPages}`))
+    }
+
+    if (searchTerm) {
+      console.log(chalk.gray(`\nSearch: ${searchTerm}`))
+    }
+
+    console.log(chalk.yellow('\nNavigation:'))
+    console.log(chalk.yellow('  ↑/↓    Move between themes'))
+    console.log(chalk.yellow('  ←/→    Move between pages'))
+    console.log(chalk.yellow('  Type   Filter themes by name'))
+    console.log(chalk.yellow('  Enter  Select highlighted theme'))
+    console.log(chalk.yellow('  s      Skip current store'))
+    console.log(chalk.yellow('  q      Quit'))
+  }
+
+  updateDisplay()
+
+  return new Promise((resolve) => {
+    const handleKey = (key) => {
+      if (key === '\x03' || key === 'q') { // Ctrl+C or 'q'
+        process.stdin.setRawMode(false)
+        process.stdin.pause()
+        console.log(chalk.yellow('\nQuitting theme backup...'))
+        process.exit(0)
+        return
+      }
+
+      if (key === 's') { // Skip store
+        process.stdin.setRawMode(false)
+        process.stdin.pause()
+        console.log(chalk.yellow(`\nSkipping ${store}...`))
+        resolve(null)
+        return
+      }
+
+      if (key === '\r') { // Enter
+        process.stdin.setRawMode(false)
+        process.stdin.pause()
+        const sortedThemes = getSortedThemes()
+        resolve(sortedThemes[selectedIndex])
+        return
+      }
+
+      if (key === '\x1B[A') { // Up arrow
+        selectedIndex = Math.max(0, selectedIndex - 1)
+        if (selectedIndex < (currentPage - 1) * pageSize) {
+          currentPage = Math.max(1, currentPage - 1)
+        }
+      } else if (key === '\x1B[B') { // Down arrow
+        selectedIndex = Math.min(filteredThemes.length - 1, selectedIndex + 1)
+        if (selectedIndex >= currentPage * pageSize) {
+          currentPage = Math.min(Math.ceil(filteredThemes.length / pageSize), currentPage + 1)
+        }
+      } else if (key === '\x1B[C') { // Right arrow
+        if (currentPage < Math.ceil(filteredThemes.length / pageSize)) {
+          currentPage++
+          selectedIndex = (currentPage - 1) * pageSize
+        }
+      } else if (key === '\x1B[D') { // Left arrow
+        if (currentPage > 1) {
+          currentPage--
+          selectedIndex = (currentPage - 1) * pageSize
+        }
+      } else if (key === '\x7F') { // Backspace
+        searchTerm = searchTerm.slice(0, -1)
+        filteredThemes = filterThemes(themes, searchTerm)
+        currentPage = 1
+        selectedIndex = 0
+      } else if (key.length === 1 && key >= ' ' && key <= '~') { // Printable characters
+        searchTerm += key
+        filteredThemes = filterThemes(themes, searchTerm)
+        currentPage = 1
+        selectedIndex = 0
+      }
+
+      updateDisplay()
+    }
+
+    process.stdin.on('data', (data) => {
+      const key = data.toString()
+      handleKey(key)
+    })
+  })
+}
+
+// Function to handle theme deletion when at limit
+async function selectThemesToDelete(store, themes, requiredCount = 1) {
+  let selectedIndices = new Set()
+  let currentPage = 1
+  const pageSize = 10
+  let highlightedIndex = 0
+  let searchTerm = ''
+  let filteredThemes = themes.filter(t => t.role !== 'live') // Don't allow deleting live theme
+  let errorMessage = ''
+
+  // Enable raw mode for real-time input
+  process.stdin.setRawMode(true)
+  process.stdin.resume()
+
+  const clearScreen = () => {
+    process.stdout.write('\x1B[2J\x1B[H')
+  }
+
+  const updateDisplay = () => {
+    clearScreen()
+    if (requiredCount > 0) {
+      console.log(chalk.bold.red(`\n${store} - Theme limit reached (${themes.length} themes)`))
+      console.log(chalk.bold.yellow(`Select ${requiredCount} theme(s) to delete:`))
+    } else {
+      console.log(chalk.bold(`\n${store} - Select themes to delete:`))
+    }
+    console.log(chalk.bold('----------------------------------------'))
+
+    const start = (currentPage - 1) * pageSize
+    const end = start + pageSize
+    const pageThemes = filteredThemes.slice(start, end)
+
+    pageThemes.forEach((theme, index) => {
+      const globalIndex = start + index
+      const isHighlighted = globalIndex === highlightedIndex
+      const isSelected = selectedIndices.has(globalIndex)
+      const line = `${theme.name} (ID: ${theme.id})`
+
+      let prefix = isSelected ? '[✓] ' : '[ ] '
+
+      if (isHighlighted && isSelected) {
+        console.log(chalk.bgRed.white(prefix + line))
+      } else if (isHighlighted) {
+        console.log(chalk.bgCyan.black(prefix + line))
+      } else if (isSelected) {
+        console.log(chalk.red(prefix + line))
+      } else {
+        console.log(chalk.cyan(prefix + line))
+      }
+    })
+
+    if (filteredThemes.length > pageSize) {
+      const totalPages = Math.ceil(filteredThemes.length / pageSize)
+      console.log(chalk.gray(`\nPage ${currentPage} of ${totalPages}`))
+    }
+
+    if (searchTerm) {
+      console.log(chalk.gray(`\nSearch: ${searchTerm}`))
+    }
+
+    if (requiredCount > 0) {
+      const isEnoughSelected = selectedIndices.size >= requiredCount
+      if (isEnoughSelected) {
+        console.log(chalk.green(`\nSelected: ${selectedIndices.size} / ${requiredCount} required`))
+      } else {
+        console.log(chalk.yellow(`\nSelected: ${selectedIndices.size} / ${requiredCount} required`))
+      }
+    } else {
+      console.log(chalk.gray(`\nSelected: ${selectedIndices.size}`))
+    }
+
+    if (errorMessage) {
+      console.log(chalk.red.bold(`\n⚠ ${errorMessage}`))
+    }
+
+    console.log(chalk.yellow('\nNavigation:'))
+    console.log(chalk.yellow('  ↑/↓    Move between themes'))
+    console.log(chalk.yellow('  ←/→    Move between pages'))
+    console.log(chalk.yellow('  Space  Toggle selection'))
+    console.log(chalk.yellow('  Type   Filter themes by name'))
+    console.log(chalk.yellow('  Enter  Confirm deletion'))
+    console.log(chalk.yellow('  q      Quit'))
+  }
+
+  updateDisplay()
+
+  return new Promise((resolve) => {
+    const handleKey = (key) => {
+      if (key === '\x03' || key === 'q') { // Ctrl+C or 'q'
+        process.stdin.setRawMode(false)
+        process.stdin.pause()
+        console.log(chalk.yellow('\nQuitting theme backup...'))
+        process.exit(0)
+        return
+      }
+
+      if (key === '\r') { // Enter
+        if (requiredCount === 0 || selectedIndices.size >= requiredCount) {
+          process.stdin.setRawMode(false)
+          process.stdin.pause()
+          const themesToDelete = Array.from(selectedIndices).map(i => filteredThemes[i])
+          resolve(themesToDelete)
+          return
+        }
+        // Not enough selected - show error message
+        errorMessage = `Please select at least ${requiredCount} theme(s) to delete (use Spacebar to select)`
+        updateDisplay()
+        return
+      }
+
+      if (key === ' ') { // Space - toggle selection
+        errorMessage = '' // Clear error on any action
+        if (selectedIndices.has(highlightedIndex)) {
+          selectedIndices.delete(highlightedIndex)
+        } else {
+          selectedIndices.add(highlightedIndex)
+        }
+      } else if (key === '\x1B[A') { // Up arrow
+        errorMessage = '' // Clear error on any action
+        highlightedIndex = Math.max(0, highlightedIndex - 1)
+        if (highlightedIndex < (currentPage - 1) * pageSize) {
+          currentPage = Math.max(1, currentPage - 1)
+        }
+      } else if (key === '\x1B[B') { // Down arrow
+        errorMessage = '' // Clear error on any action
+        highlightedIndex = Math.min(filteredThemes.length - 1, highlightedIndex + 1)
+        if (highlightedIndex >= currentPage * pageSize) {
+          currentPage = Math.min(Math.ceil(filteredThemes.length / pageSize), currentPage + 1)
+        }
+      } else if (key === '\x1B[C') { // Right arrow
+        errorMessage = '' // Clear error on any action
+        if (currentPage < Math.ceil(filteredThemes.length / pageSize)) {
+          currentPage++
+          highlightedIndex = (currentPage - 1) * pageSize
+        }
+      } else if (key === '\x1B[D') { // Left arrow
+        errorMessage = '' // Clear error on any action
+        if (currentPage > 1) {
+          currentPage--
+          highlightedIndex = (currentPage - 1) * pageSize
+        }
+      } else if (key === '\x7F') { // Backspace
+        errorMessage = '' // Clear error on any action
+        searchTerm = searchTerm.slice(0, -1)
+        filteredThemes = themes.filter(t => t.role !== 'live')
+        filteredThemes = filterThemes(filteredThemes, searchTerm)
+        selectedIndices.clear()
+        currentPage = 1
+        highlightedIndex = 0
+      } else if (key.length === 1 && key >= ' ' && key <= '~') { // Printable characters
+        errorMessage = '' // Clear error on any action
+        searchTerm += key
+        filteredThemes = themes.filter(t => t.role !== 'live')
+        filteredThemes = filterThemes(filteredThemes, searchTerm)
+        selectedIndices.clear()
+        currentPage = 1
+        highlightedIndex = 0
+      }
+
+      updateDisplay()
+    }
+
+    process.stdin.on('data', (data) => {
+      const key = data.toString()
+      handleKey(key)
+    })
+  })
+}
+
+// Function to delete themes
+async function deleteThemes(store, themes) {
+  console.log(chalk.yellow(`\nDeleting ${themes.length} theme(s)...`))
+
+  for (const theme of themes) {
+    try {
+      console.log(chalk.gray(`  Deleting: ${theme.name} (ID: ${theme.id})`))
+      execSync(`shopify theme delete -t=${theme.id} -s=${store} --force`, { stdio: 'inherit' })
+      console.log(chalk.green(`  ✓ Deleted: ${theme.name}`))
+    } catch (error) {
+      console.error(chalk.red(`  ✗ Failed to delete ${theme.name}:`))
+      console.error(chalk.red(`    ${error.message}`))
+      return false
+    }
+  }
+
+  return true
+}
+
+// Function to backup a theme
+async function backupTheme(store, theme) {
+  const date = new Date()
+  const today = `${String(date.getDate()).padStart(2, '0')}/${String(date.getMonth() + 1).padStart(2, '0')}/${date.getFullYear()}` // DD/MM/YYYY
+  const backupName = `${theme.name} (Backup ${today})`
+  const tempPath = path.join(process.cwd(), '.temp-backup')
+
+  try {
+    // Clean up any existing temp folder and recreate it
+    if (fs.existsSync(tempPath)) {
+      fs.rmSync(tempPath, { recursive: true, force: true })
+    }
+    fs.mkdirSync(tempPath, { recursive: true })
+
+    console.log(chalk.gray(`\nPulling theme: ${theme.name}...`))
+    execSync(`shopify theme pull -t=${theme.id} -s=${store} --path ${tempPath}`, { stdio: 'inherit' })
+
+    console.log(chalk.gray(`\nPushing as new theme: ${backupName}...`))
+    execSync(`shopify theme push -s=${store} --unpublished --path ${tempPath} --theme="${backupName}"`, { stdio: 'inherit' })
+
+    console.log(chalk.green(`\n✓ Successfully backed up theme: ${theme.name}`))
+    console.log(chalk.gray(`  New theme: ${backupName}`))
+
+    // Clean up temp folder
+    fs.rmSync(tempPath, { recursive: true, force: true })
+
+    return true
+  } catch (error) {
+    console.error(chalk.red(`\n✗ Failed to backup theme ${theme.name}:`))
+    console.error(chalk.red(error.message))
+
+    // Clean up temp folder even on failure
+    if (fs.existsSync(tempPath)) {
+      fs.rmSync(tempPath, { recursive: true, force: true })
+    }
+
+    return false
+  }
+}
+
+// Function to prompt user for yes/no
+async function promptYesNo(message) {
+  process.stdin.setRawMode(true)
+  process.stdin.resume()
+
+  console.log(chalk.yellow(`\n${message}`))
+  console.log(chalk.gray('Press Y for Yes, N for No'))
+
+  return new Promise((resolve) => {
+    const handleKey = (key) => {
+      const keyStr = key.toString().toLowerCase()
+
+      if (keyStr === 'y') {
+        process.stdin.setRawMode(false)
+        process.stdin.pause()
+        resolve(true)
+        return
+      }
+
+      if (keyStr === 'n') {
+        process.stdin.setRawMode(false)
+        process.stdin.pause()
+        resolve(false)
+        return
+      }
+
+      if (key === '\x03') { // Ctrl+C
+        process.stdin.setRawMode(false)
+        process.stdin.pause()
+        console.log(chalk.yellow('\nQuitting...'))
+        process.exit(0)
+      }
+    }
+
+    process.stdin.on('data', handleKey)
+  })
+}
+
+// Pre-flight check to ensure Shopify CLI authentication
+async function checkAuthentication(store) {
+  try {
+    console.log(chalk.gray(`Checking authentication for ${store}...`))
+    execSync(`shopify theme info -s=${store}`, {
+      encoding: 'utf8',
+      stdio: 'inherit' // Allow interactive authentication
+    })
+    return true
+  } catch (error) {
+    console.error(chalk.red(`\nAuthentication failed for ${store}`))
+    console.error(chalk.yellow('Please run: shopify auth login'))
+    return false
+  }
+}
+
+async function runBackup() {
+  const stores = readStoresFromConfig()
+
+  console.log(chalk.bold('\n---------------------------------'))
+  console.log(chalk.bold('SHOPIFY THEME BACKUP'))
+  console.log(chalk.bold('---------------------------------\n'))
+
+  // Pre-flight authentication check for first store
+  if (stores.length > 0) {
+    console.log(chalk.yellow('Checking Shopify CLI authentication...\n'))
+    const isAuthenticated = await checkAuthentication(stores[0])
+    if (!isAuthenticated) {
+      process.exit(1)
+    }
+    console.log(chalk.green('✓ Authentication verified\n'))
+  }
+
+  for (const store of stores) {
+    console.log(chalk.bold(`\nProcessing ${store}:`))
+
+    // Get all themes
+    const themes = await getStoreThemes(store)
+    if (!themes) {
+      console.error(chalk.red('Failed to fetch themes, skipping store'))
+      continue
+    }
+
+    // Check if at theme limit (100 themes) - MUST delete
+    if (themes.length >= 100) {
+      console.log(chalk.red(`\n⚠ Theme limit reached: ${themes.length} themes`))
+      console.log(chalk.yellow('You must delete at least 1 theme before creating a backup.\n'))
+
+      const themesToDelete = await selectThemesToDelete(store, themes, 1)
+      if (!themesToDelete || themesToDelete.length === 0) {
+        console.log(chalk.yellow('No themes selected for deletion, skipping store'))
+        continue
+      }
+
+      const deleteSuccess = await deleteThemes(store, themesToDelete)
+      if (!deleteSuccess) {
+        console.log(chalk.red('Failed to delete themes, skipping store'))
+        continue
+      }
+
+      console.log(chalk.green('\n✓ Theme deletion complete'))
+    }
+    // Check if >20 themes - OPTIONAL delete
+    else if (themes.length > 20) {
+      const wantToDelete = await promptYesNo(`You have ${themes.length} themes currently. Would you like to delete any?`)
+
+      if (wantToDelete) {
+        const themesToDelete = await selectThemesToDelete(store, themes, 0) // 0 = optional, any number
+        if (themesToDelete && themesToDelete.length > 0) {
+          const deleteSuccess = await deleteThemes(store, themesToDelete)
+          if (!deleteSuccess) {
+            console.log(chalk.red('Failed to delete some themes, but continuing...'))
+          } else {
+            console.log(chalk.green('\n✓ Theme deletion complete'))
+          }
+        }
+      }
+    }
+
+    // Select theme to backup
+    const selectedTheme = await selectTheme(store, 'Please select theme to backup')
+    if (!selectedTheme) {
+      console.log(chalk.yellow('No theme selected, skipping store'))
+      continue
+    }
+
+    // Backup the theme
+    await backupTheme(store, selectedTheme)
+  }
+
+  console.log(chalk.bold('\n---------------------------------'))
+  console.log(chalk.bold.green('✓ BACKUP COMPLETE'))
+  console.log(chalk.bold('---------------------------------\n'))
+}
+
+runBackup().catch(console.error)

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@by-association-only/theme-backup",
+  "version": "1.0.0",
+  "description": "Backup Shopify themes across multiple stores.",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "bao-theme-backup": "index.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baoagency/theme-backup.git"
+  },
+  "author": "By Association Only",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/baoagency/theme-backup/issues"
+  },
+  "homepage": "https://github.com/baoagency/theme-backup#readme",
+  "devDependencies": {}
+}
+