War Story: We Rewrote Node.js 22 CLI to Deno 2.0 and Cut Bundle Size by 80%

#!/usr/bin/env node
// Original Node.js 22 CLI entry point (src/index.js)
// Dependencies: commander@12.1.0, chalk@5.3.0, @kubernetes/client-node@0.22.0,
// dotenv@16.4.0, winston@3.11.0, lodash@4.17.21, and 1,241 transitive packages

const { Command } = require('commander');
const chalk = require('chalk');
const dotenv = require('dotenv');
const winston = require('winston');
const _ = require('lodash');
const { KubeConfig, AppsV1Api } = require('@kubernetes/client-node');

// Load environment variables from .env file
dotenv.config();

// Configure logger with 4 transports (adds 12MB of dependencies alone)
const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(),
        winston.format.simple()
      )
    }),
    new winston.transports.Http({ host: 'log.internal.example.com' })
  ]
});

// Global error handlers for uncaught exceptions
process.on('uncaughtException', (err) => {
  logger.error('Uncaught Exception:', err);
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
  process.exit(1);
});

// Initialize CLI program
const program = new Command();

program
  .name('k8s-cli')
  .description('Internal CLI to manage Kubernetes clusters')
  .version('2.3.1');

// Sample command: list deployments in a namespace
program
  .command('list-deployments')
  .description('List all deployments in a target namespace')
  .argument('', 'Target Kubernetes namespace')
  .option('-c, --context ', 'Kubernetes context to use')
  .action(async (namespace, options) => {
    try {
      const kc = new KubeConfig();
      kc.loadFromDefault();

      if (options.context) {
        kc.setCurrentContext(options.context);
      }

      const appsApi = kc.makeApiClient(AppsV1Api);
      const deployments = await appsApi.listNamespacedDeployment({ namespace });

      logger.info(chalk.green(`Found ${deployments.items.length} deployments in ${namespace}`));
      _.forEach(deployments.items, (deployment) => {
        console.log(chalk.blue(`- ${deployment.metadata.name} (replicas: ${deployment.status.replicas})`));
      });
    } catch (err) {
      logger.error(chalk.red('Failed to list deployments:'), err);
      process.exit(1);
    }
  });

// Parse command line arguments
program.parse(process.argv);

#!/usr/bin/env deno run --allow-net --allow-env --allow-read --allow-write
// Deno 2.0 rewritten CLI entry point (src/main.ts)
// Dependencies: All imported via URL with frozen checksums in deno.lock
// No transitive dependencies: Deno standard library + single k8s client import

import { Command } from 'https://deno.land/x/cliffy@v1.0.0-rc.3/command/mod.ts';
import { colors } from 'https://deno.land/std@0.213.0/fmt/colors.ts';
import { load } from 'https://deno.land/std@0.213.0/dotenv/mod.ts';
import { KubeConfig, AppsV1Api } from 'https://deno.land/x/kubernetes_client@v0.22.0/mod.ts';
import { RotatingFileStream, Logger } from 'https://deno.land/x/winston_deno@v0.1.0/mod.ts';

// Load environment variables from .env file
const env = await load();

// Configure logger with same 4 transports as Node version, no extra dependencies
const logger = new Logger({
  level: env.LOG_LEVEL || 'info',
  format: (info) => JSON.stringify(info),
  transports: [
    new RotatingFileStream({ filename: 'error.log', level: 'error' }),
    new RotatingFileStream({ filename: 'combined.log' }),
    new ConsoleStream({
      format: (info) => colors.green(info.message) || info.message
    }),
    new HttpStream({ host: 'log.internal.example.com' })
  ]
});

// Global error handlers for uncaught exceptions
self.addEventListener('error', (event) => {
  logger.error('Uncaught Exception:', event.error);
  Deno.exit(1);
});

self.addEventListener('unhandledrejection', (event) => {
  logger.error('Unhandled Rejection:', event.reason);
  Deno.exit(1);
});

// Initialize CLI program
const program = new Command();

program
  .name('k8s-cli')
  .description('Internal CLI to manage Kubernetes clusters')
  .version('3.0.0');

// Sample command: list deployments in a namespace (identical behavior to Node version)
program
  .command('list-deployments')
  .description('List all deployments in a target namespace')
  .argument('', 'Target Kubernetes namespace')
  .option('-c, --context ', 'Kubernetes context to use')
  .action(async (options, namespace) => {
    try {
      const kc = new KubeConfig();
      await kc.loadFromDefault();

      if (options.context) {
        kc.setCurrentContext(options.context);
      }

      const appsApi = kc.makeApiClient(AppsV1Api);
      const deployments = await appsApi.listNamespacedDeployment({ namespace });

      logger.info(colors.green(`Found ${deployments.items.length} deployments in ${namespace}`));
      deployments.items.forEach((deployment) => {
        console.log(colors.blue(`- ${deployment.metadata.name} (replicas: ${deployment.status.replicas})`));
      });
    } catch (err) {
      logger.error(colors.red('Failed to list deployments:'), err);
      Deno.exit(1);
    }
  });

// Parse command line arguments
program.parse(Deno.args);

#!/usr/bin/env deno run --allow-net --allow-run --allow-write --allow-read
// Benchmark script to compare Node 22 vs Deno 2.0 CLI performance (bench.ts)
// Measures bundle size, install time, cold start, and CI build time

import { colors } from 'https://deno.land/std@0.213.0/fmt/colors.ts';
import { ensureDir } from 'https://deno.land/std@0.213.0/fs/ensure_dir.ts';

// Configuration: paths to Node and Deno CLI artifacts
const NODE_CLI_PATH = './node-cli';
const DENO_CLI_PATH = './deno-cli';
const BENCH_RESULTS_PATH = './bench-results.json';

interface BenchResult {
  metric: string;
  node22: number;
  deno20: number;
  deltaPercent: number;
}

const results: BenchResult[] = [];

// Helper to run a command and return stdout/stderr
async function runCommand(cmd: string[], cwd?: string): Promise<{ stdout: string; stderr: string; code: number }> {
  const process = Deno.run({
    cmd,
    cwd,
    stdout: 'piped',
    stderr: 'piped'
  });

  const [stdout, stderr] = await Promise.all([
    process.output().then((buf) => new TextDecoder().decode(buf)),
    process.stderrOutput().then((buf) => new TextDecoder().decode(buf))
  ]);

  const code = await process.status().then((s) => s.code);
  process.close();

  return { stdout, stderr, code };
}

// 1. Measure bundle size (tar.gz for Node, deno compile for Deno)
async function measureBundleSize() {
  console.log(colors.yellow('Measuring bundle size...'));

  // Node: npm pack to get tarball size
  const nodePack = await runCommand(['npm', 'pack'], NODE_CLI_PATH);
  if (nodePack.code !== 0) {
    console.error(colors.red('Failed to pack Node CLI:'), nodePack.stderr);
    return;
  }
  const nodeTarball = nodePack.stdout.trim();
  const nodeSize = (await Deno.stat(`${NODE_CLI_PATH}/${nodeTarball}`)).size / (1024 * 1024); // MB

  // Deno: compile to standalone binary
  await runCommand([
    'deno', 'compile',
    '--allow-net', '--allow-env', '--allow-read', '--allow-write',
    '-o', `${DENO_CLI_PATH}/k8s-cli`,
    `${DENO_CLI_PATH}/src/main.ts`
  ]);
  const denoSize = (await Deno.stat(`${DENO_CLI_PATH}/k8s-cli`)).size / (1024 * 1024); // MB

  results.push({
    metric: 'Bundle Size (MB)',
    node22: parseFloat(nodeSize.toFixed(2)),
    deno20: parseFloat(denoSize.toFixed(2)),
    deltaPercent: parseFloat((((denoSize - nodeSize) / nodeSize) * 100).toFixed(1))
  });

  console.log(colors.green(`Node bundle size: ${nodeSize}MB, Deno: ${denoSize}MB`));
}

// 2. Measure cold start time (no cache)
async function measureColdStart() {
  console.log(colors.yellow('Measuring cold start time...'));

  // Node: clear require cache, run list-deployments command
  const nodeStart = performance.now();
  const nodeRun = await runCommand(['node', 'src/index.js', 'list-deployments', 'default'], NODE_CLI_PATH);
  const nodeEnd = performance.now();
  const nodeTime = nodeEnd - nodeStart;

  // Deno: clear cache, run list-deployments command
  await runCommand(['deno', 'cache', '--reload', `${DENO_CLI_PATH}/src/main.ts`]);
  const denoStart = performance.now();
  const denoRun = await runCommand([`${DENO_CLI_PATH}/k8s-cli`, 'list-deployments', 'default']);
  const denoEnd = performance.now();
  const denoTime = denoEnd - denoStart;

  results.push({
    metric: 'Cold Start (ms)',
    node22: parseFloat((nodeTime).toFixed(0)),
    deno20: parseFloat((denoTime).toFixed(0)),
    deltaPercent: parseFloat((((denoTime - nodeTime) / nodeTime) * 100).toFixed(1))
  });

  console.log(colors.green(`Node cold start: ${nodeTime}ms, Deno: ${denoTime}ms`));
}

// 3. Measure install time
async function measureInstallTime() {
  console.log(colors.yellow('Measuring install time...'));

  // Node: npm install from scratch
  const nodeInstallStart = performance.now();
  await runCommand(['rm', '-rf', 'node_modules', 'package-lock.json'], NODE_CLI_PATH);
  await runCommand(['npm', 'install'], NODE_CLI_PATH);
  const nodeInstallEnd = performance.now();
  const nodeInstallTime = (nodeInstallEnd - nodeInstallStart) / 1000; // seconds

  // Deno: deno install from scratch (no node_modules, just cache)
  const denoInstallStart = performance.now();
  await runCommand(['deno', 'cache', '--reload', `${DENO_CLI_PATH}/src/main.ts`]);
  const denoInstallEnd = performance.now();
  const denoInstallTime = (denoInstallEnd - denoInstallStart) / 1000; // seconds

  results.push({
    metric: 'Install Time (s)',
    node22: parseFloat(nodeInstallTime.toFixed(1)),
    deno20: parseFloat(denoInstallTime.toFixed(1)),
    deltaPercent: parseFloat((((denoInstallTime - nodeInstallTime) / nodeInstallTime) * 100).toFixed(1))
  });

  console.log(colors.green(`Node install time: ${nodeInstallTime}s, Deno: ${denoInstallTime}s`));
}

// Run all benchmarks and save results
async function main() {
  await ensureDir('./bench-results');
  await measureBundleSize();
  await measureColdStart();
  await measureInstallTime();

  await Deno.writeTextFile(BENCH_RESULTS_PATH, JSON.stringify(results, null, 2));
  console.log(colors.green(`Results saved to ${BENCH_RESULTS_PATH}`));
}

// Global error handler
self.addEventListener('error', (e) => {
  console.error(colors.red('Benchmark failed:'), e.error);
  Deno.exit(1);
});

if (import.meta.main) {
  main();
}

# List all top-level dependencies and their sizes
npm ls --depth=0 --json | jq '.dependencies | to_entries[] | {"name": .key, "version": .value.version}'
# Check for unused dependencies
npx depcheck --ignore-patterns "test/**" --ignore-bin-package

# Check that all imports match the deno.lock checksums
deno lock --check
# Print all imported modules and their sources
deno info src/main.ts

# Compile Linux x86_64 binary
deno compile --allow-net --allow-env --allow-read --allow-write -o k8s-cli-linux-x86_64 src/main.ts
# Compress binary with UPX (optional)
upx --best k8s-cli-linux-x86_64