@seanmozeik/s3up 0.3.1

package/src/lib/state.ts

@@ -0,0 +1,145 @@
+// src/lib/state.ts
+// Manages .s3up state files for resumable uploads
+
+import path from 'node:path';
+
+export interface CompletedPart {
+  partNumber: number;
+  etag: string;
+}
+
+export interface UploadState {
+  version: 1;
+  uploadId: string;
+  bucket: string;
+  key: string;
+  fileSize: number;
+  fileModified: number;
+  chunkSize: number;
+  totalParts: number;
+  completedParts: CompletedPart[];
+  createdAt: number;
+  provider: string;
+  endpoint: string;
+}
+
+/**
+ * Get the state file path for a given file
+ */
+export function getStateFilePath(filePath: string): string {
+  const dir = path.dirname(filePath);
+  const name = path.basename(filePath);
+  return path.join(dir, `.${name}.s3up`);
+}
+
+/**
+ * Load state from file, returns null if not found or invalid
+ */
+export async function loadState(filePath: string): Promise<UploadState | null> {
+  const stateFile = getStateFilePath(filePath);
+  const file = Bun.file(stateFile);
+
+  if (!(await file.exists())) {
+    return null;
+  }
+
+  try {
+    const content = await file.text();
+    const state = JSON.parse(content) as UploadState;
+
+    // Validate version
+    if (state.version !== 1) {
+      return null;
+    }
+
+    return state;
+  } catch {
+    // Corrupted state file
+    return null;
+  }
+}
+
+/**
+ * Save state to file
+ */
+export async function saveState(filePath: string, state: UploadState): Promise<void> {
+  const stateFile = getStateFilePath(filePath);
+  await Bun.write(stateFile, JSON.stringify(state, null, 2));
+}
+
+/**
+ * Delete state file
+ */
+export async function deleteState(filePath: string): Promise<void> {
+  const stateFile = getStateFilePath(filePath);
+  const file = Bun.file(stateFile);
+
+  if (await file.exists()) {
+    await Bun.write(stateFile, ''); // Clear content
+    const fs = await import('node:fs/promises');
+    await fs.unlink(stateFile);
+  }
+}
+
+/**
+ * Add a completed part to state and save
+ */
+export async function addCompletedPart(
+  filePath: string,
+  state: UploadState,
+  part: CompletedPart
+): Promise<void> {
+  // Check if part already exists
+  const existing = state.completedParts.findIndex((p) => p.partNumber === part.partNumber);
+  if (existing >= 0) {
+    state.completedParts[existing] = part;
+  } else {
+    state.completedParts.push(part);
+  }
+
+  // Keep sorted by part number
+  state.completedParts.sort((a, b) => a.partNumber - b.partNumber);
+
+  await saveState(filePath, state);
+}
+
+/**
+ * Check if file has changed since state was created
+ */
+export async function hasFileChanged(filePath: string, state: UploadState): Promise<boolean> {
+  const file = Bun.file(filePath);
+  const stat = await file.stat();
+
+  return file.size !== state.fileSize || stat.mtime.getTime() !== state.fileModified;
+}
+
+/**
+ * Create initial state for a new upload
+ */
+export function createInitialState(
+  uploadId: string,
+  bucket: string,
+  key: string,
+  fileSize: number,
+  fileModified: number,
+  chunkSize: number,
+  provider: string,
+  endpoint: string
+): UploadState {
+  const totalParts = Math.ceil(fileSize / chunkSize);
+
+  return {
+    bucket,
+    chunkSize,
+    completedParts: [],
+    createdAt: Date.now(),
+    endpoint,
+    fileModified,
+    fileSize,
+    key,
+    provider,
+    totalParts,
+    uploadId,
+    version: 1
+  };
+}

package/src/lib/upload.ts

@@ -0,0 +1,120 @@
+// src/lib/upload.ts
+import type { S3Config } from './providers.js';
+import { getEndpoint } from './providers.js';
+
+export interface UploadResult {
+  filename: string;
+  size: number;
+  publicUrl: string;
+  success: true;
+}
+
+export interface UploadError {
+  filename: string;
+  error: string;
+  success: false;
+}
+
+export type UploadOutcome = UploadResult | UploadError;
+
+export interface UploadProgress {
+  activeFiles: Set<string>;
+  completed: number;
+  total: number;
+}
+
+/**
+ * Format bytes to human readable string
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(1))} ${sizes[i]}`;
+}
+
+/**
+ * Render progress string for spinner
+ */
+export function renderProgress(progress: UploadProgress): string {
+  if (progress.activeFiles.size === 0) {
+    return `Uploaded ${progress.completed}/${progress.total} files`;
+  }
+  const active = [...progress.activeFiles].join(', ');
+  return `[${progress.completed}/${progress.total}] ${active}`;
+}
+
+/**
+ * Concurrency-limited parallel execution
+ */
+export async function runWithConcurrency<T, R>(
+  items: T[],
+  limit: number,
+  fn: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  const executing = new Set<Promise<void>>();
+  let currentIndex = 0;
+
+  for (const item of items) {
+    const index = currentIndex++;
+    const promise = fn(item, index).then((result) => {
+      results[index] = result;
+      executing.delete(promise);
+    });
+    executing.add(promise);
+
+    if (executing.size >= limit) {
+      await Promise.race(executing);
+    }
+  }
+
+  await Promise.all(executing);
+  return results;
+}
+
+/**
+ * Upload a single file to S3
+ */
+export async function uploadFile(
+  file: { path: string; name: string; size: number },
+  config: S3Config
+): Promise<UploadOutcome> {
+  try {
+    const fileContent = Bun.file(file.path);
+    const endpoint = getEndpoint(config);
+
+    const response = await fetch(`s3://${config.bucket}/${file.name}`, {
+      body: fileContent.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}/${file.name}`;
+
+    return {
+      filename: file.name,
+      publicUrl,
+      size: file.size,
+      success: true
+    };
+  } catch (err) {
+    return {
+      error: err instanceof Error ? err.message : String(err),
+      filename: file.name,
+      success: false
+    };
+  }
+}

package/src/ui/banner.ts

@@ -0,0 +1,47 @@
+// src/ui/banner.ts
+
+import { dirname, join } from 'node:path';
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+// Embed font file for Bun standalone executable
+// @ts-expect-error - Bun-specific import attribute
+import fontPath from '../../node_modules/figlet/fonts/Slant.flf' with { type: 'file' };
+import { gradientColors } from './theme.js';
+
+// Create custom gradient using Catppuccin Frappe colors
+const bannerGradient = gradient([...gradientColors.banner]);
+
+// Lazy font loading for bytecode caching compatibility (no top-level await)
+let fontLoaded = false;
+
+async function ensureFontLoaded(): Promise<void> {
+  if (fontLoaded) return;
+  // In dev: fontPath is absolute. In bundled builds: fontPath is relative
+  // Use Bun.main for runtime path (import.meta.dir returns source dir with bytecode)
+  const resolvedFontPath = fontPath.startsWith('/') ? fontPath : join(dirname(Bun.main), fontPath);
+  const fontContent = await Bun.file(resolvedFontPath).text();
+  figlet.parseFont('Slant', fontContent);
+  fontLoaded = true;
+}
+
+/**
+ * Display the ASCII art banner with gradient colors
+ */
+export async function showBanner(): Promise<void> {
+  await ensureFontLoaded();
+
+  const banner = figlet.textSync('s3up', {
+    font: 'Slant',
+    horizontalLayout: 'default'
+  });
+
+  const indent = '  ';
+  const indentedBanner = banner
+    .split('\n')
+    .map((line) => indent + line)
+    .join('\n');
+
+  console.log();
+  console.log(`\n${bannerGradient(indentedBanner)}\n`);
+  console.log();
+}

package/src/ui/setup.ts

@@ -0,0 +1,161 @@
+// src/ui/setup.ts
+import * as p from '@clack/prompts';
+import { PROVIDERS, type Provider, type S3Config, saveConfig } from '../lib/providers.js';
+import { showBanner } from './banner.js';
+import { frappe, theme } from './theme.js';
+
+/**
+ * Interactive setup flow for configuring S3 credentials
+ */
+export async function setup(): Promise<void> {
+  await showBanner();
+  p.intro(frappe.text('Configure S3 credentials'));
+
+  // Provider selection
+  const providerOptions = Object.entries(PROVIDERS).map(([key, info]) => ({
+    hint: info.description,
+    label: info.name,
+    value: key as Provider
+  }));
+
+  const provider = await p.select({
+    message: 'Select your S3 provider:',
+    options: providerOptions
+  });
+
+  if (p.isCancel(provider)) {
+    p.outro(frappe.subtext1('Cancelled'));
+    process.exit(0);
+  }
+
+  const providerInfo = PROVIDERS[provider];
+  const config: Partial<S3Config> = { provider };
+
+  // Provider-specific prompts
+  if (providerInfo.requiresRegion && providerInfo.regions) {
+    const region = await p.select({
+      message: `${providerInfo.name} Region:`,
+      options: providerInfo.regions.map((r) => ({ label: r, value: r }))
+    });
+
+    if (p.isCancel(region)) {
+      p.outro(frappe.subtext1('Cancelled'));
+      process.exit(0);
+    }
+    config.region = region;
+  } else if (providerInfo.requiresRegion) {
+    const region = await p.text({
+      message: `${providerInfo.name} Region:`,
+      validate: (v) => (v?.trim() ? undefined : 'Region is required')
+    });
+
+    if (p.isCancel(region)) {
+      p.outro(frappe.subtext1('Cancelled'));
+      process.exit(0);
+    }
+    config.region = region.trim();
+  }
+
+  if (providerInfo.requiresAccountId) {
+    const accountId = await p.text({
+      message: 'Account ID:',
+      validate: (v) => (v?.trim() ? undefined : 'Account ID is required')
+    });
+
+    if (p.isCancel(accountId)) {
+      p.outro(frappe.subtext1('Cancelled'));
+      process.exit(0);
+    }
+    config.accountId = accountId.trim();
+  }
+
+  if (providerInfo.requiresEndpoint) {
+    const endpoint = await p.text({
+      message: 'S3 Endpoint URL:',
+      validate: (v) => {
+        if (!v?.trim()) return 'Endpoint is required';
+        try {
+          new URL(v.trim());
+          return undefined;
+        } catch {
+          return 'Must be a valid URL';
+        }
+      }
+    });
+
+    if (p.isCancel(endpoint)) {
+      p.outro(frappe.subtext1('Cancelled'));
+      process.exit(0);
+    }
+    config.endpoint = endpoint.trim();
+  }
+
+  // Common prompts
+  const accessKeyId = await p.text({
+    message: 'Access Key ID:',
+    validate: (v) => (v?.trim() ? undefined : 'Access Key ID is required')
+  });
+
+  if (p.isCancel(accessKeyId)) {
+    p.outro(frappe.subtext1('Cancelled'));
+    process.exit(0);
+  }
+  config.accessKeyId = accessKeyId.trim();
+
+  const secretAccessKey = await p.password({
+    message: 'Secret Access Key:',
+    validate: (v) => (v?.trim() ? undefined : 'Secret Access Key is required')
+  });
+
+  if (p.isCancel(secretAccessKey)) {
+    p.outro(frappe.subtext1('Cancelled'));
+    process.exit(0);
+  }
+  config.secretAccessKey = secretAccessKey.trim();
+
+  const bucket = await p.text({
+    message: 'Bucket name:',
+    validate: (v) => (v?.trim() ? undefined : 'Bucket name is required')
+  });
+
+  if (p.isCancel(bucket)) {
+    p.outro(frappe.subtext1('Cancelled'));
+    process.exit(0);
+  }
+  config.bucket = bucket.trim();
+
+  const publicUrlBase = await p.text({
+    message: 'Public URL base (for generating links):',
+    validate: (v) => {
+      if (!v?.trim()) return 'Public URL base is required';
+      try {
+        new URL(v.trim());
+        return undefined;
+      } catch {
+        return 'Must be a valid URL';
+      }
+    }
+  });
+
+  if (p.isCancel(publicUrlBase)) {
+    p.outro(frappe.subtext1('Cancelled'));
+    process.exit(0);
+  }
+  config.publicUrlBase = publicUrlBase.trim().replace(/\/$/, '');
+
+  // Store secrets
+  const s = p.spinner();
+  s.start('Storing credentials...');
+
+  try {
+    await saveConfig(config as S3Config);
+    s.stop(theme.success('Credentials stored securely'));
+    p.outro(
+      theme.success(`Setup complete! Run s3up <files...> to upload to ${providerInfo.name}.`)
+    );
+  } catch (err) {
+    s.stop(theme.error('Failed to store credentials'));
+    p.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}

package/src/ui/theme.ts

@@ -0,0 +1,140 @@
+// src/ui/theme.ts
+import pc from 'picocolors';
+
+// Catppuccin Frappe palette
+// https://github.com/catppuccin/catppuccin
+const palette = {
+  base: '#303446',
+  blue: '#8caaee',
+  crust: '#232634',
+  flamingo: '#eebebe',
+  green: '#a6d189',
+  lavender: '#babbf1',
+  mantle: '#292c3c',
+  maroon: '#ea999c',
+  mauve: '#ca9ee6',
+  overlay0: '#737994',
+  overlay1: '#838ba7',
+  overlay2: '#949cbb',
+  peach: '#ef9f76',
+  pink: '#f4b8e4',
+  red: '#e78284',
+  rosewater: '#f2d5cf',
+  sapphire: '#85c1dc',
+  sky: '#99d1db',
+  subtext0: '#a5adce',
+  subtext1: '#b5bfe2',
+  surface0: '#414559',
+  surface1: '#51576d',
+  surface2: '#626880',
+  teal: '#81c8be',
+  text: '#c6d0f5',
+  yellow: '#e5c890'
+} as const;
+
+// ANSI 256-color approximations for Catppuccin Frappe
+const ansi = {
+  base: 236,
+  blue: 111,
+  crust: 234,
+  flamingo: 217,
+  green: 150,
+  lavender: 147,
+  mantle: 235,
+  maroon: 217,
+  mauve: 183,
+  overlay0: 60,
+  overlay1: 103,
+  overlay2: 103,
+  peach: 216,
+  pink: 218,
+  red: 210,
+  rosewater: 224,
+  sapphire: 110,
+  sky: 117,
+  subtext0: 146,
+  subtext1: 146,
+  surface0: 59,
+  surface1: 59,
+  surface2: 60,
+  teal: 116,
+  text: 189,
+  yellow: 223
+} as const;
+
+// Color functions using ANSI 256 colors
+function ansiColor(code: number): (text: string) => string {
+  return (text: string) => `\x1b[38;5;${code}m${text}\x1b[0m`;
+}
+
+function ansiBg(code: number): (text: string) => string {
+  return (text: string) => `\x1b[48;5;${code}m${text}\x1b[0m`;
+}
+
+// Theme colors as functions
+export const frappe = {
+  base: ansiColor(ansi.base),
+  bg: {
+    base: ansiBg(ansi.base),
+    surface0: ansiBg(ansi.surface0),
+    surface1: ansiBg(ansi.surface1)
+  },
+  blue: ansiColor(ansi.blue),
+  crust: ansiColor(ansi.crust),
+  flamingo: ansiColor(ansi.flamingo),
+  green: ansiColor(ansi.green),
+  lavender: ansiColor(ansi.lavender),
+  mantle: ansiColor(ansi.mantle),
+  maroon: ansiColor(ansi.maroon),
+  mauve: ansiColor(ansi.mauve),
+  overlay0: ansiColor(ansi.overlay0),
+  overlay1: ansiColor(ansi.overlay1),
+  overlay2: ansiColor(ansi.overlay2),
+  peach: ansiColor(ansi.peach),
+  pink: ansiColor(ansi.pink),
+  red: ansiColor(ansi.red),
+  rosewater: ansiColor(ansi.rosewater),
+  sapphire: ansiColor(ansi.sapphire),
+  sky: ansiColor(ansi.sky),
+  subtext0: ansiColor(ansi.subtext0),
+  subtext1: ansiColor(ansi.subtext1),
+  surface0: ansiColor(ansi.surface0),
+  surface1: ansiColor(ansi.surface1),
+  surface2: ansiColor(ansi.surface2),
+  teal: ansiColor(ansi.teal),
+  text: ansiColor(ansi.text),
+  yellow: ansiColor(ansi.yellow)
+} as const;
+
+// Semantic aliases for common use cases
+export const theme = {
+  accent: frappe.mauve,
+  dim: frappe.surface2,
+  error: frappe.red,
+  info: frappe.blue,
+  link: frappe.peach,
+  muted: frappe.overlay1,
+  primary: frappe.mauve,
+  secondary: frappe.pink,
+  subtle: frappe.subtext0,
+  success: frappe.green,
+  text: frappe.text,
+  warning: frappe.yellow
+} as const;
+
+// Gradient colors for banner (hex values for gradient-string)
+export const gradientColors = {
+  banner: [palette.mauve, palette.pink, palette.flamingo]
+} as const;
+
+// Box border colors (hex for boxen)
+export const boxColors = {
+  default: palette.surface2,
+  error: palette.red,
+  info: palette.blue,
+  primary: palette.mauve,
+  success: palette.green
+} as const;
+
+// Re-export picocolors for basic formatting
+export { pc };