@adsuploader/cli 0.2.0 → 0.2.1

package/README.md

@@ -45,6 +45,7 @@ This package includes a `SKILL.md` file that describes every command and option
 | `ads presets` | List saved presets |
 | `ads presets:save --from-ad <id> --name <name>` | Save an existing ad as an API preset |
 | `ads upload <files...>` | Upload images and videos |
+| `ads upload --retry-failed [batchId]` | Retry failed files into the same upload batch |
 | `ads uploads` | List recent upload batches |
 | `ads create spec.json` | Create ads from spec |
 | `ads create:preview spec.json` | Dry run |

package/SKILL.md

@@ -41,6 +41,8 @@ Every ad creation follows three steps:
 ```bash
 ads upload hero.jpg banner.mp4
 ads upload ./my-creatives/          # entire directory
+ads upload --retry-failed           # retry latest failed batch
+ads upload --retry-failed batch_abc123
 ```
 
 Returns a **batch ID** (e.g. `batch_abc123`) — you'll need this for the spec file. Files are uploaded directly to the selected ad account's Facebook media library, so the batch ID is tied to that account.
@@ -52,6 +54,7 @@ Files are staged in parallel and transient network failures are retried automati
 | `--concurrency <n>` | Parallel staging uploads, 1-6 (default: 4) |
 | `--upload-timeout <ms>` | Per-file R2 upload timeout (default: 120000) |
 | `--api-timeout <ms>` | API request timeout (default: 60000) |
+| `--retry-failed [batchId]` | Retry failed files into the same batch; defaults to the latest saved failed batch |
 
 ### 2. Preview (dry run)
 

package/dist/cli.cjs

@@ -1142,8 +1142,8 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path3 = require("node:path");
-    var fs4 = require("node:fs");
+    var path4 = require("node:path");
+    var fs5 = require("node:fs");
     var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2124,7 +2124,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs4.existsSync(executableFile)) return;
+        if (fs5.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2142,11 +2142,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path3.resolve(baseDir, baseName);
-          if (fs4.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path3.extname(baseName))) return void 0;
+          const localBin = path4.resolve(baseDir, baseName);
+          if (fs5.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path4.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs4.existsSync(`${localBin}${ext}`)
+            (ext) => fs5.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2158,21 +2158,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs4.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path3.resolve(
-            path3.dirname(resolvedScriptPath),
+          executableDir = path4.resolve(
+            path4.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path3.basename(
+            const legacyName = path4.basename(
               this._scriptPath,
-              path3.extname(this._scriptPath)
+              path4.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2183,7 +2183,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path3.extname(executableFile));
+        launchWithNode = sourceExt.includes(path4.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -3030,7 +3030,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path3.basename(filename, path3.extname(filename));
+        this._name = path4.basename(filename, path4.extname(filename));
         return this;
       }
       /**
@@ -3044,9 +3044,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path4) {
-        if (path4 === void 0) return this._executableDir;
-        this._executableDir = path4;
+      executableDir(path5) {
+        if (path5 === void 0) return this._executableDir;
+        this._executableDir = path5;
         return this;
       }
       /**
@@ -4186,8 +4186,8 @@ function createClient(opts = {}) {
       throw new Error(`Refusing to connect over insecure HTTP: ${baseUrl}. Use HTTPS or localhost.`);
     }
   }
-  async function request(method, path3, { body, query, requiresAccount = true, raw = false } = {}) {
-    const url = new URL(`/api/v1${path3}`, baseUrl);
+  async function request(method, path4, { body, query, requiresAccount = true, raw = false } = {}) {
+    const url = new URL(`/api/v1${path4}`, baseUrl);
     if (query) {
       for (const [k3, v2] of Object.entries(query)) {
         if (v2 != null) url.searchParams.set(k3, v2);
@@ -4250,9 +4250,9 @@ function createClient(opts = {}) {
     throw new Error(`API request failed after ${maxAttempts} attempt(s)`);
   }
   return {
-    get: (path3, opts2) => request("GET", path3, { ...opts2, requiresAccount: opts2?.requiresAccount ?? true }),
-    post: (path3, body, opts2) => request("POST", path3, { body, ...opts2 }),
-    del: (path3, body, opts2) => request("DELETE", path3, { body, ...opts2 }),
+    get: (path4, opts2) => request("GET", path4, { ...opts2, requiresAccount: opts2?.requiresAccount ?? true }),
+    post: (path4, body, opts2) => request("POST", path4, { body, ...opts2 }),
+    del: (path4, body, opts2) => request("DELETE", path4, { body, ...opts2 }),
     accounts: {
       list: () => request("GET", "/accounts", { requiresAccount: false })
     },
@@ -4278,7 +4278,7 @@ function createClient(opts = {}) {
     },
     uploads: {
       list: (query) => request("GET", "/uploads", { query }),
-      init: (files) => request("POST", "/uploads/init", { body: { files } }),
+      init: (files, { batchId } = {}) => request("POST", "/uploads/init", { body: { files, ...batchId ? { batchId } : {} } }),
       process: (batchId, file) => request("POST", `/uploads/${batchId}/process`, { body: file }),
       finalize: (batchId) => request("POST", `/uploads/${batchId}/finalize`, { body: {} }),
       status: (batchId) => request("GET", `/uploads/${batchId}`)
@@ -4353,6 +4353,9 @@ function printSuccess(msg) {
 function printError(msg) {
   console.error(`  ${import_picocolors3.default.red("\u2716")} ${msg}`);
 }
+function printWarn(msg) {
+  console.log(`  ${import_picocolors3.default.yellow("\u26A0")} ${msg}`);
+}
 function printInfo(msg) {
   console.log(`  ${import_picocolors3.default.blue("\u2139")} ${msg}`);
 }
@@ -4801,6 +4804,23 @@ function pagesCommand() {
 
 // src/commands/ad.js
 var import_picocolors8 = __toESM(require_picocolors(), 1);
+
+// src/lib/profile-display.js
+var NOT_SET = "not set";
+function formatProfileValues(profile) {
+  const pageId = profile?.page?.id || null;
+  const pageName = profile?.page?.name || null;
+  const instagramId = profile?.instagram?.id || null;
+  const instagramUsername = profile?.instagram?.username || null;
+  const threadsId = profile?.threads?.id || null;
+  return {
+    page: pageName && pageId ? `${pageName} (${pageId})` : pageId || NOT_SET,
+    instagram: instagramUsername && instagramId ? `@${instagramUsername} (${instagramId})` : instagramId || NOT_SET,
+    threads: threadsId || NOT_SET
+  };
+}
+
+// src/commands/ad.js
 function truncate(str, max = 120, expanded = false) {
   if (!str || expanded || str.length <= max) return str;
   return str.slice(0, max) + "...";
@@ -4820,6 +4840,15 @@ function adCommand() {
     console.log(`  ${import_picocolors8.default.bold("Status:")}    ${statusColor(ad.status)}`);
     console.log(`  ${import_picocolors8.default.bold("Campaign:")}  ${ad.campaignId}`);
     console.log(`  ${import_picocolors8.default.bold("Ad Set:")}    ${ad.adSetId}`);
+    if (ad.profile) {
+      const profile = formatProfileValues(ad.profile);
+      const label = (name) => import_picocolors8.default.bold(name.padEnd(12));
+      const display = (value) => value === "not set" ? import_picocolors8.default.dim(value) : value;
+      console.log("");
+      console.log(`  ${label("Page:")}${display(profile.page)}`);
+      console.log(`  ${label("Instagram:")}${display(profile.instagram)}`);
+      console.log(`  ${label("Threads:")}${display(profile.threads)}`);
+    }
     if (ad.creative) {
       const label = (name) => import_picocolors8.default.bold(name.padEnd(15));
       const exp = !!opts.expanded;
@@ -4975,9 +5004,70 @@ function presetsSaveCommand() {
 }
 
 // src/commands/upload.js
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_picocolors10 = __toESM(require_picocolors(), 1);
+
+// src/lib/upload-state.js
 var import_fs2 = __toESM(require("fs"), 1);
 var import_path2 = __toESM(require("path"), 1);
-var import_picocolors10 = __toESM(require_picocolors(), 1);
+var import_os2 = __toESM(require("os"), 1);
+var DEFAULT_CONFIG_DIR = import_path2.default.join(import_os2.default.homedir(), ".config", "adsuploader");
+function uploadsDir(baseDir = DEFAULT_CONFIG_DIR) {
+  return import_path2.default.join(baseDir, "uploads");
+}
+function stateFile(batchId, baseDir = DEFAULT_CONFIG_DIR) {
+  return import_path2.default.join(uploadsDir(baseDir), `${batchId}.json`);
+}
+function ensureUploadsDir(baseDir = DEFAULT_CONFIG_DIR) {
+  import_fs2.default.mkdirSync(uploadsDir(baseDir), { recursive: true, mode: 448 });
+}
+function saveFailedBatch({ batchId, accountId, failedFiles }, { baseDir } = {}) {
+  ensureUploadsDir(baseDir);
+  const data = {
+    batchId,
+    accountId: accountId || null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    failedFiles: failedFiles.map((file) => ({
+      path: file.path,
+      name: file.name,
+      type: file.type,
+      size: file.size,
+      contentType: file.contentType
+    }))
+  };
+  import_fs2.default.writeFileSync(stateFile(batchId, baseDir), JSON.stringify(data, null, 2), { mode: 384 });
+  if (process.platform !== "win32") {
+    import_fs2.default.chmodSync(stateFile(batchId, baseDir), 384);
+  }
+}
+function loadFailedBatch(batchId, { baseDir } = {}) {
+  const filePath = stateFile(batchId, baseDir);
+  if (!import_fs2.default.existsSync(filePath)) return null;
+  return JSON.parse(import_fs2.default.readFileSync(filePath, "utf8"));
+}
+function findLatestFailedBatch({ baseDir } = {}) {
+  const dir = uploadsDir(baseDir);
+  if (!import_fs2.default.existsSync(dir)) return null;
+  const batches = import_fs2.default.readdirSync(dir).filter((name) => name.endsWith(".json")).map((name) => {
+    try {
+      const data = JSON.parse(import_fs2.default.readFileSync(import_path2.default.join(dir, name), "utf8"));
+      return data?.batchId && data?.createdAt ? data : null;
+    } catch {
+      return null;
+    }
+  }).filter(Boolean).sort((a, b4) => new Date(b4.createdAt) - new Date(a.createdAt));
+  return batches[0] || null;
+}
+function clearFailedBatch(batchId, { baseDir } = {}) {
+  try {
+    import_fs2.default.unlinkSync(stateFile(batchId, baseDir));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+
+// src/commands/upload.js
 var IMAGE_EXTS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"]);
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v"]);
 var MAX_FILE_SIZE = 4 * 1024 * 1024 * 1024;
@@ -5001,19 +5091,19 @@ var MAGIC_BYTES = {
   // ftyp container — check below
 };
 function validateMagicBytes(filePath, contentType) {
-  const stat = import_fs2.default.statSync(filePath);
+  const stat = import_fs3.default.statSync(filePath);
   if (stat.size < 12) return false;
   let fd;
   try {
-    fd = import_fs2.default.openSync(filePath, "r");
+    fd = import_fs3.default.openSync(filePath, "r");
     const buf = Buffer.alloc(12);
-    import_fs2.default.readSync(fd, buf, 0, 12, 0);
-    import_fs2.default.closeSync(fd);
+    import_fs3.default.readSync(fd, buf, 0, 12, 0);
+    import_fs3.default.closeSync(fd);
     fd = null;
     return checkMagicBytes(buf, contentType);
   } finally {
     if (fd != null) try {
-      import_fs2.default.closeSync(fd);
+      import_fs3.default.closeSync(fd);
     } catch {
     }
   }
@@ -5118,8 +5208,38 @@ async function putR2WithRetry(uploadUrl, fileBuffer, contentType, {
   }
   throw new Error(`R2 upload failed after ${maxAttempts} attempt(s)`);
 }
+function isRetryableProcessError(err) {
+  const status = Number.isFinite(err?.status) ? err.status : null;
+  if (status >= 400 && status < 500) return false;
+  if (isRetryableNetworkError(err)) return true;
+  if (status >= 500) return true;
+  const message = String(err?.message || "");
+  return /is not valid JSON|Unexpected token|<!DOCTYPE/i.test(message) || message.includes("Facebook image upload failed");
+}
+async function processFileWithRetry(client, batchId, file, {
+  sleep: delay = sleep2,
+  maxAttempts = 4
+} = {}) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await client.uploads.process(batchId, {
+        name: file.name,
+        type: file.type,
+        size: file.size,
+        fileKey: file.fileKey
+      });
+    } catch (err) {
+      if (attempt < maxAttempts && isRetryableProcessError(err)) {
+        await delay(getRetryDelayMs(attempt));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Upload processing failed after ${maxAttempts} attempt(s)`);
+}
 function getFileType(filePath) {
-  const ext = import_path2.default.extname(filePath).toLowerCase();
+  const ext = import_path3.default.extname(filePath).toLowerCase();
   if (IMAGE_EXTS.has(ext)) return "image";
   if (VIDEO_EXTS.has(ext)) return "video";
   return null;
@@ -5128,22 +5248,22 @@ function resolveFiles(inputs) {
   const files = [];
   const skipped = [];
   for (const input of inputs) {
-    const resolved = import_path2.default.resolve(input);
-    if (!import_fs2.default.existsSync(resolved)) {
+    const resolved = import_path3.default.resolve(input);
+    if (!import_fs3.default.existsSync(resolved)) {
       throw new Error(`File not found: ${input}`);
     }
-    const stat = import_fs2.default.statSync(resolved);
+    const stat = import_fs3.default.statSync(resolved);
     if (stat.isDirectory()) {
-      const entries = import_fs2.default.readdirSync(resolved);
+      const entries = import_fs3.default.readdirSync(resolved);
       for (const entry of entries) {
-        const fullPath = import_path2.default.join(resolved, entry);
-        const entryStat = import_fs2.default.statSync(fullPath);
+        const fullPath = import_path3.default.join(resolved, entry);
+        const entryStat = import_fs3.default.statSync(fullPath);
         if (entryStat.isFile() && getFileType(fullPath)) {
           if (entryStat.size > MAX_FILE_SIZE || entryStat.size === 0) {
             skipped.push(`${entry} (${entryStat.size === 0 ? "empty" : "too large"})`);
             continue;
           }
-          const ct = CONTENT_TYPES[import_path2.default.extname(fullPath).toLowerCase()];
+          const ct = CONTENT_TYPES[import_path3.default.extname(fullPath).toLowerCase()];
           if (!validateMagicBytes(fullPath, ct)) {
             skipped.push(`${entry} (content does not match extension)`);
             continue;
@@ -5156,9 +5276,9 @@ function resolveFiles(inputs) {
       if (!type) throw new Error(`Unsupported file type: ${input}`);
       if (stat.size > MAX_FILE_SIZE) throw new Error(`File too large: ${input} (${formatSize(stat.size)}, max ${formatSize(MAX_FILE_SIZE)})`);
       if (stat.size === 0) throw new Error(`File is empty: ${input}`);
-      const ct = CONTENT_TYPES[import_path2.default.extname(resolved).toLowerCase()];
+      const ct = CONTENT_TYPES[import_path3.default.extname(resolved).toLowerCase()];
       if (!validateMagicBytes(resolved, ct)) throw new Error(`File content does not match its extension: ${input}`);
-      files.push({ path: resolved, name: import_path2.default.basename(resolved), size: stat.size, type, contentType: ct });
+      files.push({ path: resolved, name: import_path3.default.basename(resolved), size: stat.size, type, contentType: ct });
     }
   }
   if (skipped.length > 0) {
@@ -5166,7 +5286,43 @@ function resolveFiles(inputs) {
   }
   return files;
 }
-async function stageFiles(paths, opts) {
+function resolveRetryFiles(failedFiles) {
+  const files = [];
+  const skipped = [];
+  for (const file of failedFiles) {
+    if (!file.path || !import_fs3.default.existsSync(file.path)) {
+      skipped.push(`${file.name || import_path3.default.basename(file.path || "unknown")} (missing)`);
+      continue;
+    }
+    const stat = import_fs3.default.statSync(file.path);
+    if (!stat.isFile()) {
+      skipped.push(`${file.name || import_path3.default.basename(file.path)} (not a file)`);
+      continue;
+    }
+    const type = getFileType(file.path) || file.type;
+    if (!type) {
+      skipped.push(`${file.name || import_path3.default.basename(file.path)} (unsupported)`);
+      continue;
+    }
+    const contentType = file.contentType || CONTENT_TYPES[import_path3.default.extname(file.path).toLowerCase()];
+    if (contentType && !validateMagicBytes(file.path, contentType)) {
+      skipped.push(`${file.name || import_path3.default.basename(file.path)} (content does not match extension)`);
+      continue;
+    }
+    files.push({
+      path: file.path,
+      name: file.name || import_path3.default.basename(file.path),
+      size: stat.size,
+      type,
+      contentType
+    });
+  }
+  if (skipped.length > 0) {
+    console.error(import_picocolors10.default.yellow(`  Skipped ${skipped.length} file(s): ${skipped.join(", ")}`));
+  }
+  return files;
+}
+async function stageFiles(paths, opts, { batchId: existingBatchId, files: filesOverride } = {}) {
   const client = createClient({
     accountId: opts.account,
     timeoutMs: parsePositiveInt2(opts.apiTimeout, void 0)
@@ -5175,7 +5331,7 @@ async function stageFiles(paths, opts) {
   const uploadTimeoutMs = parsePositiveInt2(opts.uploadTimeout, DEFAULT_UPLOAD_TIMEOUT_MS);
   let files;
   try {
-    files = resolveFiles(paths);
+    files = filesOverride || resolveFiles(paths);
   } catch (err) {
     printError(err.message);
     process.exit(1);
@@ -5184,27 +5340,27 @@ async function stageFiles(paths, opts) {
     printError("No supported media files found.");
     process.exit(1);
   }
-  if (!jsonMode) {
-    console.log(`
-  ${import_picocolors10.default.bold("Uploading")} ${files.length} file(s)
-`);
-  }
   const filesMeta = files.map((f) => ({
     name: f.name,
     size: f.size,
     type: f.type,
     contentType: f.contentType
   }));
-  const initResult = await client.uploads.init(filesMeta);
+  const initResult = await client.uploads.init(filesMeta, { batchId: existingBatchId });
   const { batchId } = initResult;
   const concurrency = calculateUploadConcurrency(files, opts.concurrency);
+  if (!jsonMode) {
+    console.log(`
+  ${import_picocolors10.default.bold("Uploading")} ${files.length} file(s)  ${import_picocolors10.default.dim(`(staging concurrency: ${concurrency})`)}
+`);
+  }
   const uploadedFiles = await runBoundedConcurrency(files, concurrency, async (file, i) => {
     const r2Info = initResult.files[i];
     if (!jsonMode) {
       console.log(`  ${import_picocolors10.default.dim("\u2192")}  ${import_picocolors10.default.dim(`Uploading ${file.name}...  ${formatSize(file.size)}`)}`);
     }
     try {
-      const fileBuffer = import_fs2.default.readFileSync(file.path);
+      const fileBuffer = import_fs3.default.readFileSync(file.path);
       await putR2WithRetry(
         r2Info.uploadUrl,
         fileBuffer,
@@ -5212,40 +5368,60 @@ async function stageFiles(paths, opts) {
         { timeoutMs: uploadTimeoutMs }
       );
       return {
+        path: file.path,
         name: file.name,
         type: file.type,
         size: file.size,
+        contentType: file.contentType,
         fileKey: r2Info.fileKey
       };
     } catch (err) {
       if (!jsonMode) {
         console.log(`  ${import_picocolors10.default.red("\u2717")}  ${file.name}: ${err.message}`);
       }
-      return { name: file.name, type: file.type, fileKey: null, error: err.message };
+      return {
+        path: file.path,
+        name: file.name,
+        type: file.type,
+        size: file.size,
+        contentType: file.contentType,
+        fileKey: null,
+        error: err.message
+      };
     }
   });
-  return { client, batchId, uploadedFiles, jsonMode };
+  return { client, batchId, uploadedFiles, files, jsonMode };
 }
-async function processAndPrint(client, batchId, uploadedFiles, jsonMode) {
+async function processAndPrint(client, batchId, uploadedFiles, jsonMode, { isRetry = false } = {}) {
   const validFiles = uploadedFiles.filter((f) => f.fileKey);
   if (validFiles.length === 0) {
     printError("All uploads failed.");
-    process.exit(1);
+    return {
+      batchId,
+      status: "failed",
+      completed: 0,
+      failed: uploadedFiles.length,
+      total: 0,
+      files: [],
+      groups: [],
+      failedUploadedFiles: uploadedFiles
+    };
   }
   if (!jsonMode) {
-    console.log(`  ${import_picocolors10.default.dim("\u2192")}  ${import_picocolors10.default.dim("Finalizing uploads to Facebook...")}`);
+    console.log(`  ${import_picocolors10.default.dim("\u2192")}  ${import_picocolors10.default.dim(`Finalizing ${validFiles.length} upload(s) to Facebook...`)}`);
+    if (validFiles.some((file) => file.type === "video")) {
+      console.log(`  ${import_picocolors10.default.dim("Note: video finalization waits on Meta-side processing, so longer waits are expected.")}`);
+    }
   }
   const results = [];
   let completed = 0;
   let failed = 0;
-  for (const file of validFiles) {
+  for (const [index, file] of validFiles.entries()) {
     try {
-      const result = await client.uploads.process(batchId, {
-        name: file.name,
-        type: file.type,
-        size: file.size,
-        fileKey: file.fileKey
-      });
+      if (!jsonMode) {
+        console.log(`  ${import_picocolors10.default.dim("\u2192")}  ${import_picocolors10.default.dim(`Finalizing ${index + 1} of ${validFiles.length}: ${file.name}...`)}`);
+      }
+      const result = await processFileWithRetry(client, batchId, file);
       results.push(result);
       if (result.status === "complete") {
         completed++;
@@ -5268,7 +5444,7 @@ async function processAndPrint(client, batchId, uploadedFiles, jsonMode) {
     }
   }
   let groups = [];
-  if (completed > 1) {
+  if (isRetry ? completed >= 1 : completed > 1) {
     try {
       const finalizeResult = await client.uploads.finalize(batchId);
       groups = finalizeResult.groups || [];
@@ -5277,7 +5453,16 @@ async function processAndPrint(client, batchId, uploadedFiles, jsonMode) {
   }
   if (jsonMode) {
     printJson({ batchId, status: failed === 0 ? "complete" : completed === 0 ? "failed" : "partial", completed, failed, total: validFiles.length, files: results, groups });
-    return;
+    return {
+      batchId,
+      status: failed === 0 ? "complete" : completed === 0 ? "failed" : "partial",
+      completed,
+      failed,
+      total: validFiles.length,
+      files: results,
+      groups,
+      failedUploadedFiles: uploadedFiles.filter((file) => !file.fileKey || results.some((result) => result.name === file.name && result.status === "error"))
+    };
   }
   if (groups.length > 0) {
     console.log(`
@@ -5302,11 +5487,93 @@ async function processAndPrint(client, batchId, uploadedFiles, jsonMode) {
     console.log(`  ${import_picocolors10.default.bold("Groups:")} ${groups.length} variant group(s) detected`);
   }
   console.log("");
+  return {
+    batchId,
+    status: failed === 0 ? "complete" : completed === 0 ? "failed" : "partial",
+    completed,
+    failed,
+    total: validFiles.length,
+    files: results,
+    groups,
+    failedUploadedFiles: uploadedFiles.filter((file) => !file.fileKey || results.some((result) => result.name === file.name && result.status === "error"))
+  };
+}
+function failedFileState(uploadedFiles, summary) {
+  const failedProcessNames = new Set((summary.files || []).filter((result) => result.status === "error").map((result) => result.name));
+  return uploadedFiles.filter((file) => !file.fileKey || failedProcessNames.has(file.name)).map((file) => ({
+    path: file.path,
+    name: file.name,
+    type: file.type,
+    size: file.size,
+    contentType: file.contentType
+  }));
+}
+function updateFailedBatchState({ batchId, accountId, uploadedFiles, summary }) {
+  const failedFiles = failedFileState(uploadedFiles, summary);
+  if (failedFiles.length > 0) {
+    saveFailedBatch({ batchId, accountId, failedFiles });
+  } else {
+    clearFailedBatch(batchId);
+  }
+  return failedFiles;
+}
+async function runUploadFlow(paths, opts, { batchId, files, isRetry = false } = {}) {
+  const { client, batchId: resolvedBatchId, uploadedFiles, jsonMode } = await stageFiles(paths, opts, { batchId, files });
+  const summary = await processAndPrint(client, resolvedBatchId, uploadedFiles, jsonMode, { isRetry });
+  const failedFiles = updateFailedBatchState({
+    batchId: resolvedBatchId,
+    accountId: client.accountId,
+    uploadedFiles,
+    summary
+  });
+  if (failedFiles.length > 0 && summary.completed === 0) {
+    process.exit(1);
+  }
+}
+function resolveRetryAccount(savedAccountId, requestedAccountId) {
+  if (requestedAccountId) {
+    if (savedAccountId && requestedAccountId !== savedAccountId) {
+      printWarn(
+        `--account ${requestedAccountId} differs from the failed batch's account ${savedAccountId}; retrying under a different account is not supported and can mix accounts in one batch.`
+      );
+    }
+    return requestedAccountId;
+  }
+  return savedAccountId || void 0;
+}
+async function runRetryFailed(opts) {
+  const requestedBatchId = typeof opts.retryFailed === "string" ? opts.retryFailed : null;
+  const failedBatch = requestedBatchId ? loadFailedBatch(requestedBatchId) : findLatestFailedBatch();
+  if (!failedBatch) {
+    printError("No failed upload batch found to retry");
+    process.exit(1);
+  }
+  const files = resolveRetryFiles(failedBatch.failedFiles || []);
+  if (files.length === 0) {
+    printError("No retryable files found in failed upload batch.");
+    clearFailedBatch(failedBatch.batchId);
+    process.exit(1);
+  }
+  const account = resolveRetryAccount(failedBatch.accountId, opts.account);
+  await runUploadFlow([], { ...opts, account }, { batchId: failedBatch.batchId, files, isRetry: true });
 }
 function uploadCommand() {
-  return new Command("upload").description("Upload media files and process to Meta").argument("<paths...>", "Files or directories to upload").option("--account <id>", "Ad account ID").option("--json", "Output as JSON").option("--concurrency <n>", "Concurrent R2 staging uploads (1-6)", String(DEFAULT_UPLOAD_CONCURRENCY)).option("--upload-timeout <ms>", "R2 PUT timeout in milliseconds", String(DEFAULT_UPLOAD_TIMEOUT_MS)).option("--api-timeout <ms>", "API request timeout in milliseconds").action(async (paths, opts) => {
-    const { client, batchId, uploadedFiles, jsonMode } = await stageFiles(paths, opts);
-    await processAndPrint(client, batchId, uploadedFiles, jsonMode);
+  return new Command("upload").description("Upload media files and process to Meta").argument("[paths...]", "Files or directories to upload").option("--account <id>", "Ad account ID").option("--json", "Output as JSON").option("--concurrency <n>", "Concurrent R2 staging uploads (1-6)", String(DEFAULT_UPLOAD_CONCURRENCY)).option("--upload-timeout <ms>", "R2 PUT timeout in milliseconds", String(DEFAULT_UPLOAD_TIMEOUT_MS)).option("--api-timeout <ms>", "API request timeout in milliseconds").option("--retry-failed [batchId]", "Retry the latest failed upload batch or the specified batch ID").action(async (paths, opts) => {
+    const hasRetryFailed = opts.retryFailed != null;
+    const hasPaths = Array.isArray(paths) && paths.length > 0;
+    if (hasRetryFailed && hasPaths) {
+      printError("Do not pass file paths with --retry-failed; the failed files are loaded from saved state.");
+      process.exit(1);
+    }
+    if (hasRetryFailed) {
+      await runRetryFailed(opts);
+      return;
+    }
+    if (!hasPaths) {
+      printError("Missing required argument: paths");
+      process.exit(1);
+    }
+    await runUploadFlow(paths, opts);
   });
 }
 function uploadsCommand() {
@@ -5390,7 +5657,7 @@ function uploadsCommand() {
 }
 
 // src/commands/create.js
-var import_fs3 = __toESM(require("fs"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
 var import_picocolors12 = __toESM(require_picocolors(), 1);
 
 // src/lib/poll.js
@@ -5629,6 +5896,13 @@ async function executeCreate(body, opts, { preview = false, test = false } = {})
         if (sharedCta) console.log(`  ${import_picocolors12.default.bold("CTA:")}            ${sharedCta}`);
         if (sharedLink) console.log(`  ${import_picocolors12.default.bold("Link:")}           ${wrapLine(sharedLink, valCol)}`);
         if (sharedUrlTags) console.log(`  ${import_picocolors12.default.bold("URL Tags:")}       ${wrapLine(sharedUrlTags, valCol)}`);
+        if (result.profile) {
+          const profile = formatProfileValues(result.profile);
+          const display = (value) => value === "not set" ? import_picocolors12.default.dim(value) : value;
+          console.log(`  ${import_picocolors12.default.bold("Page:")}           ${wrapLine(display(profile.page), valCol)}`);
+          console.log(`  ${import_picocolors12.default.bold("Instagram:")}      ${wrapLine(display(profile.instagram), valCol)}`);
+          console.log(`  ${import_picocolors12.default.bold("Threads:")}        ${wrapLine(display(profile.threads), valCol)}`);
+        }
         const enh = result.enhancements;
         let enhDetail;
         if (enh === "metaDefaults") enhDetail = "Meta Defaults";
@@ -5702,7 +5976,7 @@ function buildBodyFromOpts(specFile, opts) {
   let body;
   if (specFile) {
     try {
-      const raw = import_fs3.default.readFileSync(specFile, "utf8");
+      const raw = import_fs4.default.readFileSync(specFile, "utf8");
       body = JSON.parse(raw);
     } catch (err) {
       printError(`Failed to read spec file: ${err.message}`);
@@ -5716,7 +5990,7 @@ function buildBodyFromOpts(specFile, opts) {
     if (opts.upload) body.uploadId = opts.upload;
     if (opts.textFile) {
       try {
-        body.texts = JSON.parse(import_fs3.default.readFileSync(opts.textFile, "utf8"));
+        body.texts = JSON.parse(import_fs4.default.readFileSync(opts.textFile, "utf8"));
       } catch (err) {
         printError(`Failed to read text file: ${err.message}`);
         process.exit(1);
@@ -6177,7 +6451,7 @@ function statusLabel(status) {
 }
 
 // src/cli.js
-var VERSION = true ? "0.2.0" : "0.0.0";
+var VERSION = true ? "0.2.1" : "0.0.0";
 var apiUrl = process.env.ADS_API_URL || getBaseUrl();
 if (apiUrl && (apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1"))) {
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
@@ -6219,12 +6493,12 @@ program2.addCommand(createTestCommand(), { hidden: true });
 program2.addCommand(jobsCommand());
 async function checkForUpdates() {
   try {
-    const fs4 = await import("fs");
-    const path3 = await import("path");
-    const os2 = await import("os");
-    const cacheFile = path3.join(os2.default.homedir(), ".config", "adsuploader", ".update-check");
+    const fs5 = await import("fs");
+    const path4 = await import("path");
+    const os3 = await import("os");
+    const cacheFile = path4.join(os3.default.homedir(), ".config", "adsuploader", ".update-check");
     try {
-      const stat = fs4.default.statSync(cacheFile);
+      const stat = fs5.default.statSync(cacheFile);
       if (Date.now() - stat.mtimeMs < 24 * 60 * 60 * 1e3) return;
     } catch {
     }
@@ -6233,8 +6507,8 @@ async function checkForUpdates() {
     const data = await resp.json();
     const latest = data.version;
     try {
-      fs4.default.mkdirSync(path3.dirname(cacheFile), { recursive: true });
-      fs4.default.writeFileSync(cacheFile, latest);
+      fs5.default.mkdirSync(path4.dirname(cacheFile), { recursive: true });
+      fs5.default.writeFileSync(cacheFile, latest);
     } catch {
     }
     if (latest !== VERSION) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adsuploader/cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Create Facebook ads from the command line — bulk upload media, preview configurations, and launch ads at scale",
   "author": "Ads Uploader <support@adsuploader.com> (https://adsuploader.com)",
   "license": "UNLICENSED",