ai-localize-aws-cloudfront 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,64 @@
+import { AwsConfig, CloudFrontAsset, LegacyCdnUrl } from '@ai-localize/shared';
+
+interface UploadOptions {
+    assetsDir: string;
+    force?: boolean;
+    onProgress?: (asset: string, done: number, total: number) => void;
+}
+interface UploadResult {
+    uploaded: CloudFrontAsset[];
+    skipped: string[];
+    failed: string[];
+    duration: number;
+}
+/**
+ * Uploads static assets to S3 with content-hash in filename for cache-busting.
+ */
+declare class S3Uploader {
+    private client;
+    private config;
+    constructor(config: AwsConfig);
+    uploadDirectory(options: UploadOptions): Promise<UploadResult>;
+    uploadFile(filePath: string, baseDir: string, force?: boolean): Promise<CloudFrontAsset | null>;
+    private objectExists;
+}
+
+interface InvalidationResult {
+    invalidationId: string;
+    paths: string[];
+    status: string;
+}
+declare class CloudFrontInvalidator {
+    private client;
+    private distributionId;
+    constructor(config: AwsConfig);
+    invalidate(paths?: string[]): Promise<InvalidationResult>;
+}
+
+interface MigrationOptions {
+    sourceDir: string;
+    assetsDir: string;
+    legacyCdnUrls: LegacyCdnUrl[];
+    dryRun?: boolean;
+    invalidateCache?: boolean;
+    onProgress?: (step: string) => void;
+}
+interface MigrationResult {
+    uploadedAssets: CloudFrontAsset[];
+    replacedUrls: number;
+    invalidationId?: string;
+    duration: number;
+}
+/**
+ * Orchestrates the full CDN migration:
+ * 1. Upload assets to S3
+ * 2. Replace legacy CDN URLs in source files
+ * 3. Invalidate CloudFront cache
+ */
+declare class CdnMigrator {
+    private config;
+    constructor(config: AwsConfig);
+    migrate(options: MigrationOptions): Promise<MigrationResult>;
+}
+
+export { CdnMigrator, CloudFrontInvalidator, type InvalidationResult, type MigrationOptions, type MigrationResult, S3Uploader, type UploadOptions, type UploadResult };

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import { AwsConfig, CloudFrontAsset, LegacyCdnUrl } from '@ai-localize/shared';
+
+interface UploadOptions {
+    assetsDir: string;
+    force?: boolean;
+    onProgress?: (asset: string, done: number, total: number) => void;
+}
+interface UploadResult {
+    uploaded: CloudFrontAsset[];
+    skipped: string[];
+    failed: string[];
+    duration: number;
+}
+/**
+ * Uploads static assets to S3 with content-hash in filename for cache-busting.
+ */
+declare class S3Uploader {
+    private client;
+    private config;
+    constructor(config: AwsConfig);
+    uploadDirectory(options: UploadOptions): Promise<UploadResult>;
+    uploadFile(filePath: string, baseDir: string, force?: boolean): Promise<CloudFrontAsset | null>;
+    private objectExists;
+}
+
+interface InvalidationResult {
+    invalidationId: string;
+    paths: string[];
+    status: string;
+}
+declare class CloudFrontInvalidator {
+    private client;
+    private distributionId;
+    constructor(config: AwsConfig);
+    invalidate(paths?: string[]): Promise<InvalidationResult>;
+}
+
+interface MigrationOptions {
+    sourceDir: string;
+    assetsDir: string;
+    legacyCdnUrls: LegacyCdnUrl[];
+    dryRun?: boolean;
+    invalidateCache?: boolean;
+    onProgress?: (step: string) => void;
+}
+interface MigrationResult {
+    uploadedAssets: CloudFrontAsset[];
+    replacedUrls: number;
+    invalidationId?: string;
+    duration: number;
+}
+/**
+ * Orchestrates the full CDN migration:
+ * 1. Upload assets to S3
+ * 2. Replace legacy CDN URLs in source files
+ * 3. Invalidate CloudFront cache
+ */
+declare class CdnMigrator {
+    private config;
+    constructor(config: AwsConfig);
+    migrate(options: MigrationOptions): Promise<MigrationResult>;
+}
+
+export { CdnMigrator, CloudFrontInvalidator, type InvalidationResult, type MigrationOptions, type MigrationResult, S3Uploader, type UploadOptions, type UploadResult };

package/dist/index.js

@@ -0,0 +1,203 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CdnMigrator: () => CdnMigrator,
+  CloudFrontInvalidator: () => CloudFrontInvalidator,
+  S3Uploader: () => S3Uploader
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/s3-uploader.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var import_client_s3 = require("@aws-sdk/client-s3");
+var mime = __toESM(require("mime-types"));
+var import_shared = require("@ai-localize/shared");
+var S3Uploader = class {
+  client;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.client = new import_client_s3.S3Client({
+      region: config.region || "us-east-1",
+      ...config.profile ? { credentials: { accessKeyId: "", secretAccessKey: "" } } : {}
+    });
+  }
+  async uploadDirectory(options) {
+    const startTime = Date.now();
+    const assetFiles = (0, import_shared.collectFiles)(options.assetsDir, import_shared.ASSET_EXTENSIONS, ["node_modules"]);
+    const uploaded = [];
+    const skipped = [];
+    const failed = [];
+    let done = 0;
+    for (const filePath of assetFiles) {
+      try {
+        const asset = await this.uploadFile(filePath, options.assetsDir, options.force);
+        if (asset) {
+          uploaded.push(asset);
+        } else {
+          skipped.push(filePath);
+        }
+      } catch (err) {
+        failed.push(filePath);
+        console.error(`Failed to upload ${filePath}:`, err);
+      }
+      done++;
+      options.onProgress?.(filePath, done, assetFiles.length);
+    }
+    return { uploaded, skipped, failed, duration: Date.now() - startTime };
+  }
+  async uploadFile(filePath, baseDir, force = false) {
+    const content = fs.readFileSync(filePath);
+    const hash = crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
+    const ext = path.extname(filePath);
+    const basename3 = path.basename(filePath, ext);
+    const hashedName = `${basename3}.${hash}${ext}`;
+    const relativePath = path.relative(baseDir, filePath);
+    const s3Key = path.join(this.config.assetsPrefix || "assets", path.dirname(relativePath), hashedName).replace(/\\/g, "/");
+    if (!force) {
+      const exists = await this.objectExists(s3Key);
+      if (exists) return null;
+    }
+    const contentType = mime.lookup(filePath) || "application/octet-stream";
+    await this.client.send(
+      new import_client_s3.PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: s3Key,
+        Body: content,
+        ContentType: contentType,
+        CacheControl: "public, max-age=31536000, immutable"
+      })
+    );
+    const cdnBase = this.config.cdnBaseUrl || `https://${this.config.distributionId}.cloudfront.net`;
+    return {
+      localPath: filePath,
+      s3Key,
+      hash,
+      cloudfrontUrl: `${cdnBase}/${s3Key}`,
+      contentType,
+      size: content.length
+    };
+  }
+  async objectExists(key) {
+    try {
+      await this.client.send(new import_client_s3.HeadObjectCommand({ Bucket: this.config.bucket, Key: key }));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/cloudfront-invalidator.ts
+var import_client_cloudfront = require("@aws-sdk/client-cloudfront");
+var CloudFrontInvalidator = class {
+  client;
+  distributionId;
+  constructor(config) {
+    this.distributionId = config.distributionId;
+    this.client = new import_client_cloudfront.CloudFrontClient({ region: config.region || "us-east-1" });
+  }
+  async invalidate(paths = ["/*"]) {
+    const callerReference = `ai-localize-${Date.now()}`;
+    const response = await this.client.send(
+      new import_client_cloudfront.CreateInvalidationCommand({
+        DistributionId: this.distributionId,
+        InvalidationBatch: {
+          CallerReference: callerReference,
+          Paths: { Quantity: paths.length, Items: paths }
+        }
+      })
+    );
+    return {
+      invalidationId: response.Invalidation?.Id || "",
+      paths,
+      status: response.Invalidation?.Status || "InProgress"
+    };
+  }
+};
+
+// src/cdn-migrator.ts
+var path2 = __toESM(require("path"));
+var CdnMigrator = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async migrate(options) {
+    const startTime = Date.now();
+    const { dryRun = false, onProgress } = options;
+    onProgress?.("Uploading assets to S3...");
+    let uploadedAssets = [];
+    if (!dryRun) {
+      const uploader = new S3Uploader(this.config);
+      const uploadResult = await uploader.uploadDirectory({
+        assetsDir: options.assetsDir,
+        onProgress: (asset, done, total) => onProgress?.(`Uploading ${done}/${total}: ${path2.basename(asset)}`)
+      });
+      uploadedAssets = uploadResult.uploaded;
+    }
+    onProgress?.("Replacing legacy CDN URLs...");
+    let replacedUrls = 0;
+    if (!dryRun && uploadedAssets.length > 0) {
+      const { batchReplaceCdnUrls } = await import("@ai-localize/codemods");
+      const fileUrlMap = /* @__PURE__ */ new Map();
+      for (const url of options.legacyCdnUrls) {
+        const existing = fileUrlMap.get(url.filePath) || [];
+        existing.push(url);
+        fileUrlMap.set(url.filePath, existing);
+      }
+      const results = await batchReplaceCdnUrls(fileUrlMap, uploadedAssets, dryRun);
+      replacedUrls = results.reduce((sum, r) => sum + r.replacedCount, 0);
+    }
+    let invalidationId;
+    if (!dryRun && options.invalidateCache && uploadedAssets.length > 0) {
+      onProgress?.("Invalidating CloudFront cache...");
+      const invalidator = new CloudFrontInvalidator(this.config);
+      const inv = await invalidator.invalidate(["/*"]);
+      invalidationId = inv.invalidationId;
+    }
+    return {
+      uploadedAssets,
+      replacedUrls,
+      invalidationId,
+      duration: Date.now() - startTime
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CdnMigrator,
+  CloudFrontInvalidator,
+  S3Uploader
+});

package/dist/index.mjs

@@ -0,0 +1,164 @@
+// src/s3-uploader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { S3Client, PutObjectCommand, HeadObjectCommand } from "@aws-sdk/client-s3";
+import * as mime from "mime-types";
+import { collectFiles, ASSET_EXTENSIONS } from "@ai-localize/shared";
+var S3Uploader = class {
+  client;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.client = new S3Client({
+      region: config.region || "us-east-1",
+      ...config.profile ? { credentials: { accessKeyId: "", secretAccessKey: "" } } : {}
+    });
+  }
+  async uploadDirectory(options) {
+    const startTime = Date.now();
+    const assetFiles = collectFiles(options.assetsDir, ASSET_EXTENSIONS, ["node_modules"]);
+    const uploaded = [];
+    const skipped = [];
+    const failed = [];
+    let done = 0;
+    for (const filePath of assetFiles) {
+      try {
+        const asset = await this.uploadFile(filePath, options.assetsDir, options.force);
+        if (asset) {
+          uploaded.push(asset);
+        } else {
+          skipped.push(filePath);
+        }
+      } catch (err) {
+        failed.push(filePath);
+        console.error(`Failed to upload ${filePath}:`, err);
+      }
+      done++;
+      options.onProgress?.(filePath, done, assetFiles.length);
+    }
+    return { uploaded, skipped, failed, duration: Date.now() - startTime };
+  }
+  async uploadFile(filePath, baseDir, force = false) {
+    const content = fs.readFileSync(filePath);
+    const hash = crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
+    const ext = path.extname(filePath);
+    const basename3 = path.basename(filePath, ext);
+    const hashedName = `${basename3}.${hash}${ext}`;
+    const relativePath = path.relative(baseDir, filePath);
+    const s3Key = path.join(this.config.assetsPrefix || "assets", path.dirname(relativePath), hashedName).replace(/\\/g, "/");
+    if (!force) {
+      const exists = await this.objectExists(s3Key);
+      if (exists) return null;
+    }
+    const contentType = mime.lookup(filePath) || "application/octet-stream";
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: s3Key,
+        Body: content,
+        ContentType: contentType,
+        CacheControl: "public, max-age=31536000, immutable"
+      })
+    );
+    const cdnBase = this.config.cdnBaseUrl || `https://${this.config.distributionId}.cloudfront.net`;
+    return {
+      localPath: filePath,
+      s3Key,
+      hash,
+      cloudfrontUrl: `${cdnBase}/${s3Key}`,
+      contentType,
+      size: content.length
+    };
+  }
+  async objectExists(key) {
+    try {
+      await this.client.send(new HeadObjectCommand({ Bucket: this.config.bucket, Key: key }));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/cloudfront-invalidator.ts
+import { CloudFrontClient, CreateInvalidationCommand } from "@aws-sdk/client-cloudfront";
+var CloudFrontInvalidator = class {
+  client;
+  distributionId;
+  constructor(config) {
+    this.distributionId = config.distributionId;
+    this.client = new CloudFrontClient({ region: config.region || "us-east-1" });
+  }
+  async invalidate(paths = ["/*"]) {
+    const callerReference = `ai-localize-${Date.now()}`;
+    const response = await this.client.send(
+      new CreateInvalidationCommand({
+        DistributionId: this.distributionId,
+        InvalidationBatch: {
+          CallerReference: callerReference,
+          Paths: { Quantity: paths.length, Items: paths }
+        }
+      })
+    );
+    return {
+      invalidationId: response.Invalidation?.Id || "",
+      paths,
+      status: response.Invalidation?.Status || "InProgress"
+    };
+  }
+};
+
+// src/cdn-migrator.ts
+import * as path2 from "path";
+var CdnMigrator = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async migrate(options) {
+    const startTime = Date.now();
+    const { dryRun = false, onProgress } = options;
+    onProgress?.("Uploading assets to S3...");
+    let uploadedAssets = [];
+    if (!dryRun) {
+      const uploader = new S3Uploader(this.config);
+      const uploadResult = await uploader.uploadDirectory({
+        assetsDir: options.assetsDir,
+        onProgress: (asset, done, total) => onProgress?.(`Uploading ${done}/${total}: ${path2.basename(asset)}`)
+      });
+      uploadedAssets = uploadResult.uploaded;
+    }
+    onProgress?.("Replacing legacy CDN URLs...");
+    let replacedUrls = 0;
+    if (!dryRun && uploadedAssets.length > 0) {
+      const { batchReplaceCdnUrls } = await import("@ai-localize/codemods");
+      const fileUrlMap = /* @__PURE__ */ new Map();
+      for (const url of options.legacyCdnUrls) {
+        const existing = fileUrlMap.get(url.filePath) || [];
+        existing.push(url);
+        fileUrlMap.set(url.filePath, existing);
+      }
+      const results = await batchReplaceCdnUrls(fileUrlMap, uploadedAssets, dryRun);
+      replacedUrls = results.reduce((sum, r) => sum + r.replacedCount, 0);
+    }
+    let invalidationId;
+    if (!dryRun && options.invalidateCache && uploadedAssets.length > 0) {
+      onProgress?.("Invalidating CloudFront cache...");
+      const invalidator = new CloudFrontInvalidator(this.config);
+      const inv = await invalidator.invalidate(["/*"]);
+      invalidationId = inv.invalidationId;
+    }
+    return {
+      uploadedAssets,
+      replacedUrls,
+      invalidationId,
+      duration: Date.now() - startTime
+    };
+  }
+};
+export {
+  CdnMigrator,
+  CloudFrontInvalidator,
+  S3Uploader
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "ai-localize-aws-cloudfront",
+  "version": "1.0.0",
+  "description": "S3 upload, CloudFront invalidation, CDN URL generation",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.511.0",
+    "@aws-sdk/client-cloudfront": "^3.511.0",
+    "@aws-sdk/lib-storage": "^3.511.0",
+    "mime-types": "^2.1.35",
+    "ai-localize-shared": "1.0.0",
+    "ai-localize-codemods": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/mime-types": "^2.1.4",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.1"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src --ext .ts"
+  }
+}

package/src/cdn-migrator.ts

@@ -0,0 +1,81 @@
+import * as path from "path";
+import type { AwsConfig, CloudFrontAsset, LegacyCdnUrl } from "@ai-localize/shared";
+import { S3Uploader } from "./s3-uploader.js";
+import { CloudFrontInvalidator } from "./cloudfront-invalidator.js";
+
+export interface MigrationOptions {
+  sourceDir: string;
+  assetsDir: string;
+  legacyCdnUrls: LegacyCdnUrl[];
+  dryRun?: boolean;
+  invalidateCache?: boolean;
+  onProgress?: (step: string) => void;
+}
+
+export interface MigrationResult {
+  uploadedAssets: CloudFrontAsset[];
+  replacedUrls: number;
+  invalidationId?: string;
+  duration: number;
+}
+
+/**
+ * Orchestrates the full CDN migration:
+ * 1. Upload assets to S3
+ * 2. Replace legacy CDN URLs in source files
+ * 3. Invalidate CloudFront cache
+ */
+export class CdnMigrator {
+  private config: AwsConfig;
+
+  constructor(config: AwsConfig) {
+    this.config = config;
+  }
+
+  async migrate(options: MigrationOptions): Promise<MigrationResult> {
+    const startTime = Date.now();
+    const { dryRun = false, onProgress } = options;
+
+    onProgress?.("Uploading assets to S3...");
+    let uploadedAssets: CloudFrontAsset[] = [];
+
+    if (!dryRun) {
+      const uploader = new S3Uploader(this.config);
+      const uploadResult = await uploader.uploadDirectory({
+   assetsDir: options.assetsDir,
+        onProgress: (asset, done, total) => onProgress?.(`Uploading ${done}/${total}: ${path.basename(asset)}`),
+      });
+      uploadedAssets = uploadResult.uploaded;
+    }
+
+    onProgress?.("Replacing legacy CDN URLs...");
+    let replacedUrls = 0;
+
+    if (!dryRun && uploadedAssets.length > 0) {
+      const { batchReplaceCdnUrls } = await import("@ai-localize/codemods");
+      const fileUrlMap = new Map<string, LegacyCdnUrl[]>();
+      for (const url of options.legacyCdnUrls) {
+        const existing = fileUrlMap.get(url.filePath) || [];
+        existing.push(url);
+        fileUrlMap.set(url.filePath, existing);
+      }
+      const results = await batchReplaceCdnUrls(fileUrlMap, uploadedAssets, dryRun);
+      replacedUrls = results.reduce((sum, r) => sum + r.replacedCount, 0);
+    }
+
+    let invalidationId: string | undefined;
+    if (!dryRun && options.invalidateCache && uploadedAssets.length > 0) {
+      onProgress?.("Invalidating CloudFront cache...");
+ const invalidator = new CloudFrontInvalidator(this.config);
+      const inv = await invalidator.invalidate(["/*"]);
+      invalidationId = inv.invalidationId;
+    }
+
+    return {
+      uploadedAssets,
+      replacedUrls,
+      invalidationId,
+    duration: Date.now() - startTime,
+  };
+}
+}

package/src/cloudfront-invalidator.ts

@@ -0,0 +1,37 @@
+import { CloudFrontClient, CreateInvalidationCommand } from "@aws-sdk/client-cloudfront";
+import type { AwsConfig } from "@ai-localize/shared";
+
+export interface InvalidationResult {
+  invalidationId: string;
+  paths: string[];
+  status: string;
+}
+
+export class CloudFrontInvalidator {
+  private client: CloudFrontClient;
+  private distributionId: string;
+
+  constructor(config: AwsConfig) {
+    this.distributionId = config.distributionId;
+    this.client = new CloudFrontClient({ region: config.region || "us-east-1" });
+  }
+
+async invalidate(paths: string[] = ["/*"]): Promise<InvalidationResult> {
+    const callerReference = `ai-localize-${Date.now()}`;
+    const response = await this.client.send(
+      new CreateInvalidationCommand({
+     DistributionId: this.distributionId,
+        InvalidationBatch: {
+          CallerReference: callerReference,
+       Paths: { Quantity: paths.length, Items: paths },
+    },
+      })
+    );
+
+ return {
+      invalidationId: response.Invalidation?.Id || "",
+      paths,
+      status: response.Invalidation?.Status || "InProgress",
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./s3-uploader.js";
+export * from "./cloudfront-invalidator.js";
+export * from "./cdn-migrator.js";

package/src/s3-uploader.ts

@@ -0,0 +1,110 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { S3Client, PutObjectCommand, HeadObjectCommand } from "@aws-sdk/client-s3";
+import * as mime from "mime-types";
+
+import type { AwsConfig, CloudFrontAsset } from "@ai-localize/shared";
+import { collectFiles, ASSET_EXTENSIONS } from "@ai-localize/shared";
+
+export interface UploadOptions {
+  assetsDir: string;
+  force?: boolean;
+  onProgress?: (asset: string, done: number, total: number) => void;
+}
+
+export interface UploadResult {
+  uploaded: CloudFrontAsset[];
+  skipped: string[];
+  failed: string[];
+  duration: number;
+}
+
+/**
+ * Uploads static assets to S3 with content-hash in filename for cache-busting.
+ */
+export class S3Uploader {
+  private client: S3Client;
+  private config: AwsConfig;
+
+  constructor(config: AwsConfig) {
+    this.config = config;
+    this.client = new S3Client({
+      region: config.region || "us-east-1",
+    ...(config.profile ? { credentials: { accessKeyId: "", secretAccessKey: "" } } : {}),
+    });
+  }
+
+  async uploadDirectory(options: UploadOptions): Promise<UploadResult> {
+    const startTime = Date.now();
+    const assetFiles = collectFiles(options.assetsDir, ASSET_EXTENSIONS, ["node_modules"]);
+    const uploaded: CloudFrontAsset[] = [];
+  const skipped: string[] = [];
+    const failed: string[] = [];
+    let done = 0;
+
+    for (const filePath of assetFiles) {
+      try {
+        const asset = await this.uploadFile(filePath, options.assetsDir, options.force);
+ if (asset) {
+      uploaded.push(asset);
+} else {
+   skipped.push(filePath);
+        }
+      } catch (err) {
+        failed.push(filePath);
+ console.error(`Failed to upload ${filePath}:`, err);
+      }
+      done++;
+      options.onProgress?.(filePath, done, assetFiles.length);
+    }
+
+    return { uploaded, skipped, failed, duration: Date.now() - startTime };
+  }
+
+  async uploadFile(filePath: string, baseDir: string, force = false): Promise<CloudFrontAsset | null> {
+    const content = fs.readFileSync(filePath);
+    const hash = crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
+    const ext = path.extname(filePath);
+    const basename = path.basename(filePath, ext);
+    const hashedName = `${basename}.${hash}${ext}`;
+    const relativePath = path.relative(baseDir, filePath);
+    const s3Key = path.join(this.config.assetsPrefix || "assets", path.dirname(relativePath), hashedName).replace(/\\/g, "/");
+
+    // Check if already uploaded
+    if (!force) {
+      const exists = await this.objectExists(s3Key);
+  if (exists) return null;
+    }
+
+    const contentType = mime.lookup(filePath) || "application/octet-stream";
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.config.bucket,
+      Key: s3Key,
+        Body: content,
+        ContentType: contentType,
+        CacheControl: "public, max-age=31536000, immutable",
+  })
+    );
+
+    const cdnBase = this.config.cdnBaseUrl || `https://${this.config.distributionId}.cloudfront.net`;
+    return {
+      localPath: filePath,
+      s3Key,
+      hash,
+      cloudfrontUrl: `${cdnBase}/${s3Key}`,
+      contentType,
+      size: content.length,
+    };
+  }
+
+  private async objectExists(key: string): Promise<boolean> {
+    try {
+      await this.client.send(new HeadObjectCommand({ Bucket: this.config.bucket, Key: key }));
+      return true;
+ } catch {
+  return false;
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "outDir": "./dist", "rootDir": "./src" },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}