manage-deployments.js

#!/usr/bin/env node

/**
 * Google Apps Script Deployment Manager
 *
 * This script helps manage Google Apps Script deployments by:
 * - Listing all active deployments ordered by version (most recent first)
 * - Allowing selective archiving of older deployments
 * - Never archiving @HEAD or the most recent deployment
 *
 * Usage: npm run manage-deployments
 */

const { execSync } = require('child_process');
const { checkbox, confirm } = require('@inquirer/prompts');

async function main() {
  try {
    console.log('🔧 Google Apps Script Deployment Manager\n');

    // Change to src directory where .clasp.json is located
    process.chdir('./src');

    // Get deployments
    console.log('📋 Fetching deployments...');
    const deployments = await getDeployments();

    if (deployments.length === 0) {
      console.log('❌ No deployments found.');
      return;
    }

    // Display deployments
    displayDeployments(deployments);

    // Get user selection
    const toArchive = await getUserSelection(deployments);

    if (toArchive.length === 0) {
      console.log('ℹ️  No deployments selected for archiving.');
      return;
    }

    // Confirm and archive
    const confirmed = await confirmArchiving(toArchive);
    if (!confirmed) {
      console.log('❌ Operation cancelled.');
      return;
    }

    // Archive deployments
    await archiveDeployments(toArchive);

    console.log('\n✅ Deployment management complete!');

  } catch (error) {
    console.error('❌ Error:', error.message);
    process.exit(1);
  }
}

async function getDeployments() {
  try {
    const output = execSync('clasp deployments', { encoding: 'utf8' });
    return parseDeployments(output);
  } catch (error) {
    throw new Error(`Failed to get deployments: ${error.message}`);
  }
}

function parseDeployments(output) {
  const lines = output.split('\n').filter(line => line.trim());
  const deployments = [];

  for (const line of lines) {
    const trimmed = line.trim();
    if (!trimmed || !trimmed.startsWith('- ')) continue;

    // Remove the leading "- "
    const content = trimmed.substring(2);

    // Split on " - " to separate description if present
    const parts = content.split(' - ');
    const mainPart = parts[0].trim();
    const description = parts.length > 1 ? parts.slice(1).join(' - ').trim() : '';

    // Split main part on whitespace to get ID and version
    const mainParts = mainPart.split(/\s+/);
    if (mainParts.length >= 2) {
      const deploymentId = mainParts[0];
      const version = mainParts[1];

      deployments.push({
        deploymentId,
        version,
        description,
        isHead: version === '@HEAD'
      });
    }
  }

  // Sort by version number (assuming higher version numbers are more recent)
  // @HEAD comes first, then sort by version descending (most recent first)
  deployments.sort((a, b) => {
    if (a.isHead) return -1;
    if (b.isHead) return 1;

    // Extract version numbers
    const versionA = parseInt(a.version.replace('@', '')) || 0;
    const versionB = parseInt(b.version.replace('@', '')) || 0;
    return versionB - versionA; // Descending order
  });

  return deployments;
}

function displayDeployments(deployments) {
  console.log('📋 Active Deployments (ordered by version, most recent first):\n');

  deployments.forEach((deployment, index) => {
    const isHead = deployment.isHead;
    const isMostRecent = index === 0 && !isHead;

    const status = isHead ? '🏷️  @HEAD' : isMostRecent ? '🆕 Most Recent' : '📦 Archivable';

    console.log(`${index + 1}. ${deployment.deploymentId}`);
    console.log(`   ${status}`);
    console.log(`   Version: ${deployment.version}`);
    console.log(`   Description: ${deployment.description || 'No description'}`);
    console.log('');
  });

  // Summary
  const headDeployment = deployments.find(d => d.isHead);
  const mostRecent = deployments[0];

  console.log('📊 Summary:');
  console.log(`   Total deployments: ${deployments.length}`);
  console.log(`   @HEAD deployment: ${headDeployment ? 'Present' : 'Not found'}`);
  console.log(`   Most recent: ${mostRecent.deploymentId} (v${mostRecent.version})`);
  console.log(`   Archivable: ${deployments.length - (headDeployment ? 1 : 0) - 1} deployments\n`);
}

async function getUserSelection(deployments) {
  // Filter out @HEAD and most recent deployment
  const archivable = deployments.filter((deployment, index) => {
    const isHead = deployment.isHead;
    const isMostRecent = index === 0;
    return !isHead && !isMostRecent;
  });

  if (archivable.length === 0) {
    console.log('ℹ️  No deployments available for archiving (only @HEAD and most recent exist).');
    return [];
  }

  const choices = archivable.map((deployment, index) => ({
    name: `${deployment.deploymentId} (v${deployment.version}) - ${deployment.description || 'No description'}`,
    value: deployment.deploymentId,
    short: deployment.deploymentId,
  }));

  const answers = await checkbox({
    message: 'Select deployments to archive:',
    choices: choices,
    pageSize: 10,
  });

  return answers;
}

async function confirmArchiving(deploymentIds) {
  console.log(`\n🗂️  Selected ${deploymentIds.length} deployment(s) for archiving:`);
  deploymentIds.forEach(id => console.log(`   - ${id}`));

  const confirmed = await confirm({
    message: 'Are you sure you want to archive these deployments?',
    default: false,
  });

  return confirmed;
}

async function archiveDeployments(deploymentIds) {
  console.log('\n🗂️  Archiving deployments...');

  let successCount = 0;
  let failCount = 0;

  for (const deploymentId of deploymentIds) {
    try {
      console.log(`   Archiving ${deploymentId}...`);
      execSync(`clasp undeploy ${deploymentId}`, { stdio: 'inherit' });
      console.log(`   ✅ ${deploymentId} archived successfully`);
      successCount++;
    } catch (error) {
      console.log(`   ❌ Failed to archive ${deploymentId}`);
      failCount++;
    }
  }

  console.log(`\n📊 Results:`);
  console.log(`   ✅ Successfully archived: ${successCount}`);
  if (failCount > 0) {
    console.log(`   ❌ Failed to archive: ${failCount}`);
  }
}

// Run the script
if (require.main === module) {
  main().catch(console.error);
}

module.exports = { main, getDeployments, parseDeployments, displayDeployments };