@seanmozeik/s3up 0.3.1

package/src/lib/archive.ts

@@ -0,0 +1,89 @@
+// src/lib/archive.ts
+
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+
+export interface ArchiveOptions {
+  compression: number;
+  name?: string;
+}
+
+export interface ArchiveResult {
+  blob: Blob;
+  name: string;
+  size: number;
+}
+
+export function generateArchiveName(directories: string[], override?: string): string {
+  if (override) {
+    return override.endsWith('.tar.gz') ? override : `${override}.tar.gz`;
+  }
+
+  const firstName = path.basename(directories[0]);
+  const date = new Date().toISOString().split('T')[0];
+  return `${firstName}-${date}.tar.gz`;
+}
+
+async function collectFiles(
+  dirPath: string,
+  baseName: string
+): Promise<Record<string, Uint8Array>> {
+  const files: Record<string, Uint8Array> = {};
+
+  async function walk(currentPath: string, relativePath: string): Promise<void> {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name);
+      const archivePath = path.join(relativePath, entry.name);
+
+      if (entry.isDirectory()) {
+        await walk(fullPath, archivePath);
+      } else if (entry.isFile()) {
+        const content = await Bun.file(fullPath).bytes();
+        files[archivePath] = content;
+      }
+    }
+  }
+
+  await walk(dirPath, baseName);
+  return files;
+}
+
+export async function createArchive(
+  directories: string[],
+  options: ArchiveOptions
+): Promise<ArchiveResult> {
+  const allFiles: Record<string, Uint8Array> = {};
+
+  // Collect files from all directories
+  for (const dir of directories) {
+    const baseName = path.basename(dir);
+    const dirFiles = await collectFiles(dir, baseName);
+    Object.assign(allFiles, dirFiles);
+  }
+
+  // Create tarball using Bun.Archive
+  const archive = new Bun.Archive(allFiles, {
+    compress: 'gzip',
+    level: options.compression
+  });
+
+  const blob = await archive.blob();
+  const name = generateArchiveName(directories, options.name);
+
+  return {
+    blob,
+    name,
+    size: blob.size
+  };
+}
+
+export async function isDirectory(filePath: string): Promise<boolean> {
+  try {
+    const stats = await stat(filePath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}

package/src/lib/clipboard.ts

@@ -0,0 +1,41 @@
+// src/lib/clipboard.ts
+import { $ } from 'bun';
+
+/**
+ * Copy text to clipboard (cross-platform)
+ * Returns true if successful, false if no clipboard tool available
+ */
+export async function copyToClipboard(text: string): Promise<boolean> {
+  // macOS
+  if (process.platform === 'darwin') {
+    const proc = Bun.spawn(['pbcopy'], { stdin: 'pipe' });
+    proc.stdin.write(text);
+    proc.stdin.end();
+    await proc.exited;
+    return true;
+  }
+
+  // Linux: try available clipboard tools in order of preference
+  const tools: string[][] = [
+    ['xclip', '-selection', 'clipboard'],
+    ['xsel', '--clipboard', '--input'],
+    ['wl-copy'] // Wayland
+  ];
+
+  for (const cmd of tools) {
+    try {
+      const which = await $`which ${cmd[0]}`.quiet();
+      if (which.exitCode === 0) {
+        const proc = Bun.spawn(cmd, { stdin: 'pipe' });
+        proc.stdin.write(text);
+        proc.stdin.end();
+        await proc.exited;
+        return true;
+      }
+    } catch {
+      // Tool not found, try next
+    }
+  }
+
+  return false;
+}

package/src/lib/flags.test.ts

@@ -0,0 +1,72 @@
+// src/lib/flags.test.ts
+import { describe, expect, test } from 'bun:test';
+import { parseGlobalFlags, parseUploadFlags } from './flags';
+
+describe('parseGlobalFlags', () => {
+  test('parses --quiet flag', () => {
+    const result = parseGlobalFlags(['--quiet', 'file.txt']);
+    expect(result.quiet).toBe(true);
+  });
+
+  test('parses -q shorthand', () => {
+    const result = parseGlobalFlags(['-q', 'file.txt']);
+    expect(result.quiet).toBe(true);
+  });
+
+  test('parses --ci flag', () => {
+    const result = parseGlobalFlags(['--ci', 'file.txt']);
+    expect(result.ci).toBe(true);
+  });
+
+  test('returns remaining args', () => {
+    const result = parseGlobalFlags(['--quiet', '--ci', 'file.txt', 'file2.txt']);
+    expect(result.args).toEqual(['file.txt', 'file2.txt']);
+  });
+
+  test('handles no flags', () => {
+    const result = parseGlobalFlags(['file.txt']);
+    expect(result.quiet).toBe(false);
+    expect(result.ci).toBe(false);
+    expect(result.args).toEqual(['file.txt']);
+  });
+
+  test('passes through command-specific flags', () => {
+    const result = parseGlobalFlags(['prune', 'backups/', '--keep-last', '7', '--quiet']);
+    expect(result.quiet).toBe(true);
+    expect(result.args).toEqual(['prune', 'backups/', '--keep-last', '7']);
+  });
+});
+
+describe('parseUploadFlags', () => {
+  test('parses --prefix', () => {
+    const result = parseUploadFlags(['--prefix', 'backups/daily', 'file.txt']);
+    expect(result.prefix).toBe('backups/daily');
+  });
+
+  test('parses --compression', () => {
+    const result = parseUploadFlags(['--compression', '9', 'dir/']);
+    expect(result.compression).toBe(9);
+  });
+
+  test('parses --as', () => {
+    const result = parseUploadFlags(['--as', 'backup.tar.gz', 'dir/']);
+    expect(result.as).toBe('backup.tar.gz');
+  });
+
+  test('parses --fast and --slow', () => {
+    expect(parseUploadFlags(['--fast', 'file.txt']).fast).toBe(true);
+    expect(parseUploadFlags(['-f', 'file.txt']).fast).toBe(true);
+    expect(parseUploadFlags(['--slow', 'file.txt']).slow).toBe(true);
+    expect(parseUploadFlags(['-s', 'file.txt']).slow).toBe(true);
+  });
+
+  test('returns remaining paths', () => {
+    const result = parseUploadFlags(['--prefix', 'x', 'a.txt', 'b.txt']);
+    expect(result.paths).toEqual(['a.txt', 'b.txt']);
+  });
+
+  test('defaults compression to 6', () => {
+    const result = parseUploadFlags(['file.txt']);
+    expect(result.compression).toBe(6);
+  });
+});

package/src/lib/flags.ts

@@ -0,0 +1,129 @@
+// src/lib/flags.ts
+
+export interface GlobalFlags {
+  quiet: boolean;
+  ci: boolean;
+  help: boolean;
+  version: boolean;
+  args: string[];
+}
+
+export interface UploadFlags {
+  prefix?: string;
+  compression: number;
+  as?: string;
+  fast: boolean;
+  slow: boolean;
+  paths: string[];
+}
+
+export interface ListFlags {
+  json: boolean;
+  prefix?: string;
+}
+
+export interface PruneFlags {
+  olderThan?: number;
+  keepLast?: number;
+  minAge: string;
+  dryRun: boolean;
+  prefix: string;
+}
+
+export function parseGlobalFlags(args: string[]): GlobalFlags {
+  const result: GlobalFlags = {
+    args: [],
+    ci: false,
+    help: false,
+    quiet: false,
+    version: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--quiet' || arg === '-q') {
+      result.quiet = true;
+    } else if (arg === '--ci') {
+      result.ci = true;
+    } else if (arg === '--help' || arg === '-h') {
+      result.help = true;
+    } else if (arg === '--version' || arg === '-v') {
+      result.version = true;
+    } else {
+      // Pass through everything else (including command-specific flags)
+      result.args.push(arg);
+    }
+  }
+
+  return result;
+}
+
+export function parseUploadFlags(args: string[]): UploadFlags {
+  const result: UploadFlags = {
+    compression: 6,
+    fast: false,
+    paths: [],
+    slow: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--prefix' && args[i + 1]) {
+      result.prefix = args[++i];
+    } else if (arg === '--compression' && args[i + 1]) {
+      result.compression = parseInt(args[++i], 10);
+    } else if (arg === '--as' && args[i + 1]) {
+      result.as = args[++i];
+    } else if (arg === '--fast' || arg === '-f') {
+      result.fast = true;
+    } else if (arg === '--slow' || arg === '-s') {
+      result.slow = true;
+    } else if (!arg.startsWith('-')) {
+      result.paths.push(arg);
+    }
+  }
+
+  return result;
+}
+
+export function parseListFlags(args: string[]): ListFlags {
+  const result: ListFlags = {
+    json: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') {
+      result.json = true;
+    } else if (!arg.startsWith('-')) {
+      result.prefix = arg;
+    }
+  }
+
+  return result;
+}
+
+export function parsePruneFlags(args: string[]): PruneFlags {
+  const result: PruneFlags = {
+    dryRun: false,
+    minAge: '1d',
+    prefix: ''
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--older-than' && args[i + 1]) {
+      result.olderThan = parseInt(args[++i], 10);
+    } else if (arg === '--keep-last' && args[i + 1]) {
+      result.keepLast = parseInt(args[++i], 10);
+    } else if (arg === '--min-age' && args[i + 1]) {
+      result.minAge = args[++i];
+    } else if (arg === '--dry-run') {
+      result.dryRun = true;
+    } else if (!arg.startsWith('-')) {
+      result.prefix = arg;
+    }
+  }
+
+  return result;
+}