@seanmozeik/s3up 0.3.1

package/src/commands/upload.ts

@@ -0,0 +1,350 @@
+// src/commands/upload.ts
+
+import path from 'node:path';
+import * as p from '@clack/prompts';
+import boxen from 'boxen';
+
+import { createArchive, isDirectory } from '../lib/archive';
+import { type GlobalFlags, parseUploadFlags } from '../lib/flags';
+import {
+  checkResumableUpload,
+  cleanupExistingUpload,
+  type MultipartOptions,
+  uploadMultipart
+} from '../lib/multipart';
+import { formatBytes, formatUploadError, formatUploadSuccess } from '../lib/output';
+import { loadConfig, PROVIDERS, type S3Config } from '../lib/providers';
+import {
+  renderProgress,
+  runWithConcurrency,
+  type UploadError,
+  type UploadOutcome,
+  type UploadProgress,
+  type UploadResult,
+  uploadFile
+} from '../lib/upload';
+import { showBanner } from '../ui/banner';
+import { boxColors, frappe, theme } from '../ui/theme';
+
+const MULTIPART_THRESHOLD = 100 * 1024 * 1024; // 100MB
+
+const SPEED_PRESETS = {
+  default: { chunkSize: 25 * 1024 * 1024, connections: 8 },
+  fast: { chunkSize: 5 * 1024 * 1024, connections: 16 },
+  slow: { chunkSize: 50 * 1024 * 1024, connections: 4 }
+} as const;
+
+interface UploadOptions {
+  chunkSize: number;
+  connections: number;
+  forceFast?: boolean;
+}
+
+function getUploadOptions(flags: { fast: boolean; slow: boolean }): UploadOptions {
+  if (flags.fast) return { ...SPEED_PRESETS.fast, forceFast: true };
+  if (flags.slow) return SPEED_PRESETS.slow;
+  return SPEED_PRESETS.default;
+}
+
+function displayResults(results: UploadOutcome[], quiet: boolean): void {
+  if (quiet) {
+    for (const r of results) {
+      if (r.success) {
+        console.log(formatUploadSuccess(r.filename, r.publicUrl, r.size, true));
+      } else {
+        console.error(formatUploadError(r.filename, r.error));
+      }
+    }
+    return;
+  }
+
+  const successes = results.filter((r): r is UploadResult => r.success);
+  const failures = results.filter((r): r is UploadError => !r.success);
+
+  if (successes.length > 0) {
+    const content = successes
+      .map(
+        (r) =>
+          `${theme.success('✓')} ${frappe.text(r.filename)} ${theme.dim(`(${formatBytes(r.size)})`)}\n  ${theme.link(r.publicUrl)}`
+      )
+      .join('\n\n');
+
+    const box = boxen(content, {
+      borderColor: boxColors.success,
+      borderStyle: 'round',
+      padding: { bottom: 0, left: 1, right: 1, top: 0 },
+      title: `Uploaded ${successes.length} file${successes.length > 1 ? 's' : ''}`,
+      titleAlignment: 'left'
+    });
+    console.log(box);
+  }
+
+  if (failures.length > 0) {
+    for (const f of failures) {
+      p.log.error(`${f.filename}: ${f.error}`);
+    }
+  }
+}
+
+export async function upload(args: string[], globalFlags: GlobalFlags): Promise<void> {
+  const flags = parseUploadFlags(args);
+  const uploadOpts = getUploadOptions(flags);
+
+  // Load config first
+  const config = await loadConfig();
+  if (!config) {
+    if (globalFlags.ci) {
+      console.error('Error: S3UP_CONFIG not set and --ci prevents interactive setup');
+      process.exit(2);
+    }
+    if (!globalFlags.quiet) await showBanner();
+    p.log.error('S3 not configured. Run: s3up setup');
+    process.exit(2);
+  }
+
+  const providerInfo = PROVIDERS[config.provider];
+
+  // Separate files and directories
+  const files: { path: string; name: string; size: number; blob?: Blob }[] = [];
+  const directories: string[] = [];
+  const invalidPaths: string[] = [];
+
+  for (const filePath of flags.paths) {
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+
+    if (await isDirectory(absolutePath)) {
+      directories.push(absolutePath);
+    } else {
+      const file = Bun.file(absolutePath);
+      const exists = await file.exists();
+      if (exists) {
+        files.push({
+          name: path.basename(absolutePath),
+          path: absolutePath,
+          size: file.size
+        });
+      } else {
+        invalidPaths.push(filePath);
+      }
+    }
+  }
+
+  // Create tarball from directories if any
+  if (directories.length > 0) {
+    const archive = await createArchive(directories, {
+      compression: flags.compression,
+      name: flags.as
+    });
+
+    // Add archive as a "file" to upload
+    files.push({
+      blob: archive.blob,
+      name: archive.name,
+      path: '', // Will use blob directly
+      size: archive.size
+    });
+  }
+
+  if (!globalFlags.quiet) await showBanner();
+
+  // Report invalid paths
+  if (invalidPaths.length > 0 && !globalFlags.quiet) {
+    for (const f of invalidPaths) {
+      p.log.warn(`Path not found: ${f}`);
+    }
+  }
+
+  if (files.length === 0) {
+    if (globalFlags.quiet) {
+      console.error('Error: No valid files to upload');
+    } else {
+      p.outro(theme.error('No valid files to upload'));
+    }
+    process.exit(1);
+  }
+
+  // Apply prefix to keys
+  const getKey = (filename: string): string => {
+    if (flags.prefix) {
+      const normalizedPrefix = flags.prefix.replace(/^\/+|\/+$/g, '');
+      return `${normalizedPrefix}/${filename}`;
+    }
+    return filename;
+  };
+
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+
+  if (!globalFlags.quiet) {
+    p.intro(
+      frappe.text(
+        `Uploading ${files.length} file${files.length > 1 ? 's' : ''} to ${providerInfo.name} (${formatBytes(totalSize)})`
+      )
+    );
+  }
+
+  const results: UploadOutcome[] = [];
+
+  // Separate large and small files
+  const threshold = uploadOpts.forceFast ? uploadOpts.chunkSize : MULTIPART_THRESHOLD;
+  const largeFiles = files.filter((f) => f.size >= threshold && !f.blob);
+  const smallFiles = files.filter((f) => f.size < threshold || f.blob);
+
+  // Handle large files (one at a time for progress)
+  for (const file of largeFiles) {
+    // Check for resumable upload
+    const { canResume, percentComplete } = await checkResumableUpload(file.path);
+
+    if (canResume && !globalFlags.ci) {
+      const resume = await p.confirm({
+        message: `Resume incomplete upload of ${file.name}? (${percentComplete}% done)`
+      });
+
+      if (p.isCancel(resume)) {
+        if (!globalFlags.quiet) p.outro(frappe.subtext1('Cancelled'));
+        process.exit(0);
+      }
+
+      if (!resume) {
+        await cleanupExistingUpload(file.path, config);
+      }
+    } else if (canResume && globalFlags.ci) {
+      // In CI mode, always resume
+    }
+
+    if (!globalFlags.quiet) {
+      console.log(frappe.text(`\nUploading ${file.name} (${formatBytes(file.size)})...`));
+    }
+
+    const multipartOptions: MultipartOptions = {
+      chunkSize: uploadOpts.chunkSize,
+      connections: uploadOpts.connections
+    };
+
+    const key = getKey(file.name);
+    const result = await uploadMultipart(file.path, config, key, multipartOptions);
+
+    if (result.success) {
+      results.push({
+        filename: file.name,
+        publicUrl: result.publicUrl,
+        size: file.size,
+        success: true
+      });
+    } else {
+      results.push({
+        error: result.error,
+        filename: file.name,
+        success: false
+      });
+    }
+  }
+
+  // Handle small files (concurrent)
+  if (smallFiles.length > 0) {
+    const progress: UploadProgress = {
+      activeFiles: new Set(),
+      completed: 0,
+      total: smallFiles.length
+    };
+
+    let spinner: ReturnType<typeof p.spinner> | undefined;
+    if (!globalFlags.quiet) {
+      spinner = p.spinner();
+      spinner.start(renderProgress(progress));
+    }
+
+    const smallResults = await runWithConcurrency(
+      smallFiles,
+      uploadOpts.connections,
+      async (file) => {
+        progress.activeFiles.add(file.name);
+        spinner?.message(renderProgress(progress));
+
+        const key = getKey(file.name);
+
+        // Handle blob uploads (from archives)
+        let result: UploadOutcome;
+        if (file.blob) {
+          result = await uploadBlob(file.blob, key, file.name, config);
+        } else {
+          result = await uploadFile({ ...file, name: key }, config);
+        }
+
+        progress.activeFiles.delete(file.name);
+        progress.completed++;
+        spinner?.message(renderProgress(progress));
+
+        // Fix the filename in result
+        if (result.success) {
+          return { ...result, filename: file.name };
+        }
+        return { ...result, filename: file.name };
+      }
+    );
+
+    spinner?.stop(theme.success(`Uploaded ${progress.completed}/${progress.total} files`));
+    results.push(...smallResults);
+  }
+
+  if (!globalFlags.quiet) console.log();
+  displayResults(results, globalFlags.quiet);
+
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+
+  if (failCount === 0) {
+    if (!globalFlags.quiet) p.outro(theme.success('All files uploaded successfully!'));
+    process.exit(0);
+  } else if (successCount > 0) {
+    if (!globalFlags.quiet) p.outro(theme.warning(`${successCount} uploaded, ${failCount} failed`));
+    process.exit(4);
+  } else {
+    if (!globalFlags.quiet) p.outro(theme.error('All uploads failed'));
+    process.exit(1);
+  }
+}
+
+// Helper to upload a blob (for archives)
+async function uploadBlob(
+  blob: Blob,
+  key: string,
+  filename: string,
+  config: S3Config
+): Promise<UploadOutcome> {
+  try {
+    const { getEndpoint } = await import('../lib/providers');
+    const endpoint = getEndpoint(config);
+
+    const response = await fetch(`s3://${config.bucket}/${key}`, {
+      body: blob.stream(),
+      headers: {
+        'Content-Disposition': 'attachment'
+      },
+      method: 'PUT',
+      s3: {
+        accessKeyId: config.accessKeyId,
+        endpoint,
+        secretAccessKey: config.secretAccessKey
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
+    }
+
+    const publicUrl = `${config.publicUrlBase}/${key}`;
+
+    return {
+      filename,
+      publicUrl,
+      size: blob.size,
+      success: true
+    };
+  } catch (err) {
+    return {
+      error: err instanceof Error ? err.message : String(err),
+      filename,
+      success: false
+    };
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,51 @@
+// src/index.test.ts
+import { describe, expect, test } from 'bun:test';
+import { $ } from 'bun';
+
+describe('s3up CLI', () => {
+  test('--version shows version', async () => {
+    const result = await $`bun run src/index.ts --version`.text();
+    expect(result).toMatch(/^s3up v\d+\.\d+\.\d+/);
+  });
+
+  test('--help shows help', async () => {
+    const result = await $`bun run src/index.ts --help`.text();
+    expect(result).toContain('Usage:');
+    expect(result).toContain('upload');
+    expect(result).toContain('list');
+    expect(result).toContain('prune');
+  });
+
+  test('-h shows help', async () => {
+    const result = await $`bun run src/index.ts -h`.text();
+    expect(result).toContain('Usage:');
+  });
+
+  test('-v shows version', async () => {
+    const result = await $`bun run src/index.ts -v`.text();
+    expect(result).toMatch(/^s3up v\d+\.\d+\.\d+/);
+  });
+
+  test('no args shows help', async () => {
+    const result = await $`bun run src/index.ts`.text();
+    expect(result).toContain('Usage:');
+  });
+});
+
+describe('s3up upload validation', () => {
+  test('exits with error when file not found', async () => {
+    const proc = $`bun run src/index.ts upload nonexistent-file-12345.txt --ci`.nothrow();
+    const result = await proc;
+    // Should fail with exit code 1 (no valid files)
+    expect(result.exitCode).toBe(1);
+  });
+});
+
+describe('s3up prune validation', () => {
+  test('requires at least one filter', async () => {
+    const proc = $`bun run src/index.ts prune backups/`.nothrow();
+    const result = await proc;
+    expect(result.exitCode).toBe(1);
+    expect(result.stderr.toString()).toContain('--older-than or --keep-last');
+  });
+});

package/src/index.ts

@@ -0,0 +1,165 @@
+#!/usr/bin/env bun
+
+import * as p from '@clack/prompts';
+import pkg from '../package.json' with { type: 'json' };
+import { list } from './commands/list';
+import { prune } from './commands/prune';
+import { upload } from './commands/upload';
+import { parseGlobalFlags } from './lib/flags';
+import { deleteConfig } from './lib/providers';
+import { showBanner } from './ui/banner';
+import { setup } from './ui/setup';
+import { frappe, theme } from './ui/theme';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Teardown Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+async function teardown(): Promise<void> {
+  await showBanner();
+  p.intro(frappe.text('Remove stored credentials'));
+
+  const confirm = await p.confirm({
+    message: 'Remove all stored S3 credentials?'
+  });
+
+  if (p.isCancel(confirm) || !confirm) {
+    p.outro(frappe.subtext1('Cancelled'));
+    process.exit(0);
+  }
+
+  const s = p.spinner();
+  s.start('Removing credentials...');
+
+  try {
+    const removed = await deleteConfig();
+    s.stop(theme.success(`Removed ${removed} credential(s)`));
+    p.outro(frappe.subtext1('Done'));
+  } catch (err) {
+    s.stop(theme.error('Failed to remove credentials'));
+    p.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Help
+// ─────────────────────────────────────────────────────────────────────────────
+
+async function showHelp(): Promise<void> {
+  await showBanner();
+  console.log(frappe.text('Usage:'));
+  console.log(
+    `  ${theme.accent('s3up')} ${theme.dim('[options]')} ${frappe.text('<files...>')}       Upload files`
+  );
+  console.log(
+    `  ${theme.accent('s3up upload')} ${theme.dim('[options]')} ${frappe.text('<files...>')}  Upload files`
+  );
+  console.log(
+    `  ${theme.accent('s3up list')} ${theme.dim('[prefix]')}                   List bucket objects`
+  );
+  console.log(
+    `  ${theme.accent('s3up prune')} ${frappe.text('<prefix>')} ${theme.dim('[options]')}     Delete old objects`
+  );
+  console.log(`  ${theme.accent('s3up setup')}                           Configure credentials`);
+  console.log(`  ${theme.accent('s3up teardown')}                        Remove credentials`);
+  console.log();
+  console.log(frappe.text('Global options:'));
+  console.log(`  ${theme.accent('-q, --quiet')}    Minimal output for scripting`);
+  console.log(`  ${theme.accent('--ci')}           Non-interactive mode`);
+  console.log(`  ${theme.accent('-h, --help')}     Show this help message`);
+  console.log(`  ${theme.accent('-v, --version')}  Show version number`);
+  console.log();
+  console.log(frappe.text('Upload options:'));
+  console.log(`  ${theme.accent('--prefix <path>')}       Prepend path to uploaded keys`);
+  console.log(`  ${theme.accent('--as <name>')}           Override tarball filename`);
+  console.log(`  ${theme.accent('--compression <1-12>')}  Gzip level (default: 6)`);
+  console.log(
+    `  ${theme.accent('-f, --fast')}            Fast network (5MB chunks, 16 connections)`
+  );
+  console.log(
+    `  ${theme.accent('-s, --slow')}            Slow network (50MB chunks, 4 connections)`
+  );
+  console.log();
+  console.log(frappe.text('List options:'));
+  console.log(`  ${theme.accent('--json')}         Output as JSON (one object per line)`);
+  console.log();
+  console.log(frappe.text('Prune options:'));
+  console.log(`  ${theme.accent('--older-than <days>')}   Delete objects older than N days`);
+  console.log(`  ${theme.accent('--keep-last <n>')}       Keep only N most recent objects`);
+  console.log(`  ${theme.accent('--min-age <duration>')}  Minimum age to delete (default: 1d)`);
+  console.log(`  ${theme.accent('--dry-run')}             Show what would be deleted`);
+  console.log();
+  console.log(frappe.text('Examples:'));
+  console.log(`  ${theme.dim('s3up image.png')}                         Upload single file`);
+  console.log(`  ${theme.dim('s3up *.png')}                             Upload multiple files`);
+  console.log(
+    `  ${theme.dim('s3up ./workspace --prefix backups')}      Upload directory as tarball`
+  );
+  console.log(`  ${theme.dim('s3up list backups/')}                     List objects with prefix`);
+  console.log(`  ${theme.dim('s3up prune backups/ --keep-last 7')}      Keep last 7 backups`);
+  console.log();
+  console.log(frappe.subtext0('Files ≥100MB automatically use chunked parallel upload.'));
+  console.log(frappe.subtext0('Directories are automatically archived as .tar.gz files.'));
+  console.log();
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Main
+// ─────────────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = Bun.argv.slice(2);
+  const globalFlags = parseGlobalFlags(args);
+
+  // Handle --version anywhere
+  if (globalFlags.version) {
+    console.log(`s3up v${pkg.version}`);
+    process.exit(0);
+  }
+
+  // Handle --help anywhere
+  if (globalFlags.help) {
+    await showHelp();
+    process.exit(0);
+  }
+
+  const command = globalFlags.args[0];
+  const commandArgs = globalFlags.args.slice(1);
+
+  switch (command) {
+    case 'setup':
+      await setup();
+      break;
+
+    case 'teardown':
+      await teardown();
+      break;
+
+    case 'upload':
+      await upload(commandArgs, globalFlags);
+      break;
+
+    case 'list':
+      await list(commandArgs, globalFlags);
+      break;
+
+    case 'prune':
+      await prune(commandArgs, globalFlags);
+      break;
+
+    case undefined:
+      await showHelp();
+      break;
+
+    default:
+      // Treat as file paths for upload (backwards compatible)
+      await upload([command, ...commandArgs], globalFlags);
+      break;
+  }
+}
+
+main().catch((err) => {
+  console.error(theme.error(err instanceof Error ? err.message : String(err)));
+  process.exit(1);
+});

package/src/lib/archive.test.ts

@@ -0,0 +1,65 @@
+// src/lib/archive.test.ts
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { mkdir, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { createArchive, generateArchiveName } from './archive';
+
+describe('generateArchiveName', () => {
+  test('generates name from single directory', () => {
+    const name = generateArchiveName(['/path/to/workspace']);
+    expect(name).toMatch(/^workspace-\d{4}-\d{2}-\d{2}\.tar\.gz$/);
+  });
+
+  test('generates name from multiple directories using first', () => {
+    const name = generateArchiveName(['/path/to/workspace', '/path/to/config']);
+    expect(name).toMatch(/^workspace-\d{4}-\d{2}-\d{2}\.tar\.gz$/);
+  });
+
+  test('uses override name when provided', () => {
+    const name = generateArchiveName(['/path/to/workspace'], 'backup.tar.gz');
+    expect(name).toBe('backup.tar.gz');
+  });
+
+  test('adds .tar.gz if missing from override', () => {
+    const name = generateArchiveName(['/path/to/workspace'], 'backup');
+    expect(name).toBe('backup.tar.gz');
+  });
+});
+
+describe('createArchive', () => {
+  const testDir = '/tmp/s3up-archive-test';
+  const subDir1 = path.join(testDir, 'workspace');
+  const subDir2 = path.join(testDir, 'config');
+
+  beforeAll(async () => {
+    await mkdir(subDir1, { recursive: true });
+    await mkdir(subDir2, { recursive: true });
+    await Bun.write(path.join(subDir1, 'file1.txt'), 'content1');
+    await Bun.write(path.join(subDir2, 'file2.txt'), 'content2');
+  });
+
+  afterAll(async () => {
+    await rm(testDir, { force: true, recursive: true });
+  });
+
+  test('creates archive from single directory', async () => {
+    const result = await createArchive([subDir1], { compression: 6 });
+    expect(result.blob).toBeDefined();
+    expect(result.blob.size).toBeGreaterThan(0);
+    expect(result.name).toMatch(/^workspace-\d{4}-\d{2}-\d{2}\.tar\.gz$/);
+  });
+
+  test('creates archive from multiple directories', async () => {
+    const result = await createArchive([subDir1, subDir2], { compression: 6 });
+    expect(result.blob).toBeDefined();
+    expect(result.blob.size).toBeGreaterThan(0);
+  });
+
+  test('uses custom name', async () => {
+    const result = await createArchive([subDir1], {
+      compression: 6,
+      name: 'custom-backup.tar.gz'
+    });
+    expect(result.name).toBe('custom-backup.tar.gz');
+  });
+});