@adsuploader/cli 0.1.8 → 0.2.1

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;
       }
       /**
@@ -3464,7 +3464,7 @@ var {
 } = import_index.default;
 
 // src/cli.js
-var import_picocolors13 = __toESM(require_picocolors(), 1);
+var import_picocolors14 = __toESM(require_picocolors(), 1);
 
 // src/lib/config.js
 var import_fs = __toESM(require("fs"), 1);
@@ -4131,10 +4131,51 @@ var import_crypto = __toESM(require("crypto"), 1);
 
 // src/lib/client.js
 var USER_AGENT = "adsuploader-cli/0.1.0";
+var DEFAULT_API_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_ATTEMPTS = 4;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parsePositiveInt(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function isRetryableNetworkError(err) {
+  const message = String(err?.message || "").toLowerCase();
+  return err?.name === "AbortError" || err?.code === "ECONNRESET" || err?.code === "ETIMEDOUT" || message.includes("fetch failed") || message.includes("network") || message.includes("timeout");
+}
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+function shouldRetryResponse(method, status) {
+  if (status === 429) return true;
+  return method === "GET" && status >= 500;
+}
+function timeoutError(timeoutMs) {
+  return new Error(`API request timed out after ${Math.ceil(timeoutMs / 1e3)}s`);
+}
+function getRetryDelayMs(attempt, retryAfter, { baseDelayMs = 500, maxDelayMs = 8e3, jitterMs = 250 } = {}) {
+  if (retryAfter != null && Number.isFinite(retryAfter) && retryAfter > 0) {
+    return retryAfter * 1e3;
+  }
+  const exponential = Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, attempt - 1));
+  return exponential + Math.floor(Math.random() * jitterMs);
+}
+function formatApiError(resp, data) {
+  const message = data?.error || data?.message || `API error ${resp.status}`;
+  if (resp.status === 403 && /different IP address|created from a different IP|ads login/i.test(message)) {
+    return "Your network IP changed since this CLI token was created. Run `ads login` again to refresh your session.";
+  }
+  return message;
+}
 function createClient(opts = {}) {
   const token = opts.token || getToken();
   const baseUrl = opts.baseUrl || getBaseUrl();
   const accountId = opts.accountId || getDefaultAccount();
+  const fetchImpl = opts.fetchImpl || fetch;
+  const delay = opts.sleep || sleep;
+  const maxAttempts = opts.maxAttempts || DEFAULT_MAX_ATTEMPTS;
+  const timeoutMs = opts.timeoutMs || parsePositiveInt(process.env.ADS_API_TIMEOUT_MS, DEFAULT_API_TIMEOUT_MS);
   if (!token) {
     throw new Error("Not authenticated. Run `ads login` first.");
   }
@@ -4145,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);
@@ -4162,43 +4203,65 @@ function createClient(opts = {}) {
     if (body) {
       headers["Content-Type"] = "application/json";
     }
-    const resp = await fetch(url.toString(), {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : void 0,
-      redirect: "manual"
-      // Never follow redirects — prevents token leakage to redirect targets
-    });
-    if (resp.status >= 300 && resp.status < 400) {
-      throw new Error(`Unexpected redirect (${resp.status}). This may indicate a configuration issue.`);
-    }
-    if (resp.status === 429) {
-      const retryAfter = resp.headers.get("retry-after");
-      const err = new Error(`Rate limited. Retry after ${retryAfter || "60"}s`);
-      err.retryAfter = parseInt(retryAfter || "60");
-      throw err;
-    }
-    if (raw) return resp;
-    const data = await resp.json();
-    if (!resp.ok) {
-      const err = new Error(data.error || data.message || `API error ${resp.status}`);
-      err.code = data.errorCode;
-      err.status = resp.status;
-      err.details = data.details;
-      throw err;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const resp = await fetchImpl(url.toString(), {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          redirect: "manual",
+          // Never follow redirects — prevents token leakage to redirect targets
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (resp.status >= 300 && resp.status < 400) {
+          throw new Error(`Unexpected redirect (${resp.status}). This may indicate a configuration issue.`);
+        }
+        if (shouldRetryResponse(method, resp.status) && attempt < maxAttempts) {
+          const retryAfter = resp.status === 429 ? parsePositiveInt(resp.headers.get("retry-after"), null) : null;
+          await delay(getRetryDelayMs(attempt, retryAfter));
+          continue;
+        }
+        if (raw) return resp;
+        const data = await resp.json();
+        if (!resp.ok) {
+          const err = new Error(formatApiError(resp, data));
+          err.code = data.errorCode;
+          err.status = resp.status;
+          err.details = data.details;
+          throw err;
+        }
+        return data;
+      } catch (err) {
+        clearTimeout(timeout);
+        if (err.status) {
+          throw err;
+        }
+        const normalizedError = err?.name === "AbortError" ? timeoutError(timeoutMs) : err;
+        if (method === "GET" && attempt < maxAttempts && isRetryableNetworkError(normalizedError)) {
+          await delay(getRetryDelayMs(attempt));
+          continue;
+        }
+        throw normalizedError;
+      }
     }
-    return data;
+    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 })
     },
     campaigns: {
       list: (query) => request("GET", "/campaigns", { query })
     },
+    pages: {
+      list: (query) => request("GET", "/pages", { query })
+    },
     adsets: {
       list: (campaignId, query) => request("GET", `/campaigns/${campaignId}/adsets`, { query })
     },
@@ -4215,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}`)
@@ -4290,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}`);
 }
@@ -4705,8 +4771,56 @@ function adsetCommand() {
   });
 }
 
-// src/commands/ad.js
+// src/commands/pages.js
 var import_picocolors7 = __toESM(require_picocolors(), 1);
+function formatInstagram(page) {
+  if (!page.instagramId && !page.instagramUsername) return "";
+  if (page.instagramUsername && page.instagramId) return `${page.instagramUsername} (${page.instagramId})`;
+  return page.instagramUsername || page.instagramId;
+}
+function pagesCommand() {
+  return new Command("pages").description("List Facebook Pages available for profile overrides").option("--account <id>", "Ad account ID").option("--json", "Output as JSON").action(async (opts) => {
+    const client = createClient({ accountId: opts.account });
+    const { pages } = await client.pages.list();
+    if (shouldOutputJson(opts)) {
+      printJson(pages);
+      return;
+    }
+    const rows = pages.map((page) => ({
+      ...page,
+      instagram: formatInstagram(page)
+    }));
+    console.log(`
+  ${import_picocolors7.default.bold("Pages")} (${pages.length})
+`);
+    printTable(rows, [
+      { key: "id", label: "ID", maxWidth: 25 },
+      { key: "name", label: "Name", maxWidth: 40 },
+      { key: "instagram", label: "Instagram", maxWidth: 36 }
+    ]);
+    console.log("");
+  });
+}
+
+// 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) + "...";
@@ -4720,17 +4834,26 @@ function adCommand() {
       return;
     }
     console.log(`
-  ${import_picocolors7.default.bold(ad.name)}
+  ${import_picocolors8.default.bold(ad.name)}
 `);
-    console.log(`  ${import_picocolors7.default.bold("ID:")}        ${ad.id}`);
-    console.log(`  ${import_picocolors7.default.bold("Status:")}    ${statusColor(ad.status)}`);
-    console.log(`  ${import_picocolors7.default.bold("Campaign:")}  ${ad.campaignId}`);
-    console.log(`  ${import_picocolors7.default.bold("Ad Set:")}    ${ad.adSetId}`);
+    console.log(`  ${import_picocolors8.default.bold("ID:")}        ${ad.id}`);
+    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_picocolors7.default.bold(name.padEnd(15));
+      const label = (name) => import_picocolors8.default.bold(name.padEnd(15));
       const exp = !!opts.expanded;
       console.log("");
-      console.log(`  ${import_picocolors7.default.bold("Creative")}`);
+      console.log(`  ${import_picocolors8.default.bold("Creative")}`);
       if (ad.creative.headline) console.log(`    ${label("Headline:")}${truncate(ad.creative.headline, 120, exp)}`);
       if (ad.creative.headlines) console.log(`    ${label("Headlines:")}${ad.creative.headlines.map((h2) => truncate(h2, 60, exp)).join(" | ")}`);
       if (ad.creative.primaryText) console.log(`    ${label("Primary Text:")}${truncate(ad.creative.primaryText, 120, exp)}`);
@@ -4744,13 +4867,13 @@ function adCommand() {
       if (ad.creative.enhancements) console.log(`    ${label("Enhancements:")}${ad.creative.enhancements.join(", ")}`);
     }
     console.log(`
-  ${import_picocolors7.default.dim("Use this ad as a template:")} ads create --copy-from ${ad.id}
+  ${import_picocolors8.default.dim("Use this ad as a template:")} ads create --copy-from ${ad.id}
 `);
   });
 }
 
 // src/commands/presets.js
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 function presetsCommand() {
   return new Command("presets").description("List saved ad template presets").option("--account <id>", "Ad account ID").option("--json", "Output as JSON").argument("[id]", "Preset ID to show details").action(async (id, opts) => {
     const client = createClient({ accountId: opts.account });
@@ -4761,12 +4884,12 @@ function presetsCommand() {
         return;
       }
       console.log(`
-  ${import_picocolors8.default.bold(preset.name)}
+  ${import_picocolors9.default.bold(preset.name)}
 `);
       if (preset.config) {
-        console.log(`  ${import_picocolors8.default.bold("Campaign:")}  ${preset.config.campaign?.name || import_picocolors8.default.dim("\u2014")} ${import_picocolors8.default.dim(preset.config.campaign?.id || "")}`);
-        console.log(`  ${import_picocolors8.default.bold("Ad Set:")}    ${preset.config.adSet?.name || import_picocolors8.default.dim("\u2014")} ${import_picocolors8.default.dim(preset.config.adSet?.id || "")}`);
-        console.log(`  ${import_picocolors8.default.bold("Ad:")}        ${preset.config.ad?.name || import_picocolors8.default.dim("\u2014")} ${import_picocolors8.default.dim(preset.config.ad?.id || "")}`);
+        console.log(`  ${import_picocolors9.default.bold("Campaign:")}  ${preset.config.campaign?.name || import_picocolors9.default.dim("\u2014")} ${import_picocolors9.default.dim(preset.config.campaign?.id || "")}`);
+        console.log(`  ${import_picocolors9.default.bold("Ad Set:")}    ${preset.config.adSet?.name || import_picocolors9.default.dim("\u2014")} ${import_picocolors9.default.dim(preset.config.adSet?.id || "")}`);
+        console.log(`  ${import_picocolors9.default.bold("Ad:")}        ${preset.config.ad?.name || import_picocolors9.default.dim("\u2014")} ${import_picocolors9.default.dim(preset.config.ad?.id || "")}`);
       }
       console.log("");
       return;
@@ -4778,15 +4901,15 @@ function presetsCommand() {
       return;
     }
     console.log(`
-  ${import_picocolors8.default.bold("Ad Template Presets")} (${all.length})
+  ${import_picocolors9.default.bold("Ad Template Presets")} (${all.length})
 `);
     if (all.length === 0) {
-      console.log(import_picocolors8.default.dim("  No presets. Create one in the web app by saving an ad configuration."));
+      console.log(import_picocolors9.default.dim("  No presets. Create one in the web app by saving an ad configuration."));
     } else {
       printTable(all, [
         { key: "id", label: "ID", maxWidth: 28 },
         { key: "name", label: "Name", maxWidth: 40 },
-        { key: "shared", label: "Shared", color: (v2) => v2 ? import_picocolors8.default.cyan("team") : import_picocolors8.default.dim("\u2014") }
+        { key: "shared", label: "Shared", color: (v2) => v2 ? import_picocolors9.default.cyan("team") : import_picocolors9.default.dim("\u2014") }
       ]);
     }
     console.log("");
@@ -4802,13 +4925,13 @@ function textPresetsCommand() {
         return;
       }
       console.log(`
-  ${import_picocolors8.default.bold(preset.name)}
+  ${import_picocolors9.default.bold(preset.name)}
 `);
-      console.log(`  ${import_picocolors8.default.bold("Includes:")}  ${preset.includedFields?.join(", ") || "all fields"}`);
+      console.log(`  ${import_picocolors9.default.bold("Includes:")}  ${preset.includedFields?.join(", ") || "all fields"}`);
       if (preset.text) {
-        if (preset.text.titles?.length) console.log(`  ${import_picocolors8.default.bold("Headlines:")} ${preset.text.titles.join(" | ")}`);
-        if (preset.text.bodies?.length) console.log(`  ${import_picocolors8.default.bold("Bodies:")}    ${preset.text.bodies.join(" | ")}`);
-        if (preset.text.descriptions?.length) console.log(`  ${import_picocolors8.default.bold("Desc:")}      ${preset.text.descriptions.join(" | ")}`);
+        if (preset.text.titles?.length) console.log(`  ${import_picocolors9.default.bold("Headlines:")} ${preset.text.titles.join(" | ")}`);
+        if (preset.text.bodies?.length) console.log(`  ${import_picocolors9.default.bold("Bodies:")}    ${preset.text.bodies.join(" | ")}`);
+        if (preset.text.descriptions?.length) console.log(`  ${import_picocolors9.default.bold("Desc:")}      ${preset.text.descriptions.join(" | ")}`);
       }
       console.log("");
       return;
@@ -4820,16 +4943,16 @@ function textPresetsCommand() {
       return;
     }
     console.log(`
-  ${import_picocolors8.default.bold("Text Presets")} (${all.length})
+  ${import_picocolors9.default.bold("Text Presets")} (${all.length})
 `);
     if (all.length === 0) {
-      console.log(import_picocolors8.default.dim("  No text presets. Create one in the web app."));
+      console.log(import_picocolors9.default.dim("  No text presets. Create one in the web app."));
     } else {
       printTable(all, [
         { key: "id", label: "ID", maxWidth: 28 },
         { key: "name", label: "Name", maxWidth: 30 },
-        { key: "scope", label: "Scope", color: (v2) => v2 === "global" ? import_picocolors8.default.cyan("global") : import_picocolors8.default.dim("account") },
-        { key: "shared", label: "Shared", color: (v2) => v2 ? import_picocolors8.default.cyan("team") : import_picocolors8.default.dim("\u2014") }
+        { key: "scope", label: "Scope", color: (v2) => v2 === "global" ? import_picocolors9.default.cyan("global") : import_picocolors9.default.dim("account") },
+        { key: "shared", label: "Shared", color: (v2) => v2 ? import_picocolors9.default.cyan("team") : import_picocolors9.default.dim("\u2014") }
       ]);
     }
     console.log("");
@@ -4867,11 +4990,11 @@ function presetsSaveCommand() {
         return;
       }
       printSuccess(`Saved preset "${preset.name}"`);
-      console.log(`  ${import_picocolors8.default.bold("ID:")}     ${preset.id}`);
-      console.log(`  ${import_picocolors8.default.bold("Type:")}   ${preset.type}`);
-      if (preset.shared) console.log(`  ${import_picocolors8.default.bold("Shared:")} ${import_picocolors8.default.cyan("team")}`);
+      console.log(`  ${import_picocolors9.default.bold("ID:")}     ${preset.id}`);
+      console.log(`  ${import_picocolors9.default.bold("Type:")}   ${preset.type}`);
+      if (preset.shared) console.log(`  ${import_picocolors9.default.bold("Shared:")} ${import_picocolors9.default.cyan("team")}`);
       console.log(`
-  ${import_picocolors8.default.dim("Use it:")} ads create --preset ${preset.id} ...
+  ${import_picocolors9.default.dim("Use it:")} ads create --preset ${preset.id} ...
 `);
     } catch (err) {
       printError(err.message || "Failed to save preset");
@@ -4881,12 +5004,78 @@ 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_picocolors9 = __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;
+var DEFAULT_UPLOAD_CONCURRENCY = 4;
+var MAX_UPLOAD_CONCURRENCY = 6;
+var DEFAULT_UPLOAD_TIMEOUT_MS = 12e4;
+var DEFAULT_R2_MAX_ATTEMPTS = 4;
+var DEFAULT_MAX_IN_FLIGHT_BYTES = 512 * 1024 * 1024;
 var MAGIC_BYTES = {
   "image/jpeg": [[255, 216, 255]],
   "image/png": [[137, 80, 78, 71]],
@@ -4902,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 {
     }
   }
@@ -4950,8 +5139,107 @@ var CONTENT_TYPES = {
   ".webm": "video/webm",
   ".m4v": "video/x-m4v"
 };
+function parsePositiveInt2(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function normalizeConcurrency(value) {
+  return Math.min(MAX_UPLOAD_CONCURRENCY, parsePositiveInt2(value, DEFAULT_UPLOAD_CONCURRENCY));
+}
+function calculateUploadConcurrency(files, requestedConcurrency, maxInFlightBytes = DEFAULT_MAX_IN_FLIGHT_BYTES) {
+  const requested = normalizeConcurrency(requestedConcurrency);
+  const largestFileSize = Math.max(0, ...files.map((file) => Number(file.size) || 0));
+  if (largestFileSize <= 0) return requested;
+  const memoryLimited = Math.max(1, Math.floor(maxInFlightBytes / largestFileSize));
+  return Math.min(requested, memoryLimited);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runBoundedConcurrency(items, concurrency, worker) {
+  const limit = Math.max(1, Math.min(items.length || 1, concurrency));
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function runNext() {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      results[index] = await worker(items[index], index);
+    }
+  }
+  await Promise.all(Array.from({ length: limit }, runNext));
+  return results;
+}
+async function putR2WithRetry(uploadUrl, fileBuffer, contentType, {
+  fetchImpl = fetch,
+  timeoutMs = DEFAULT_UPLOAD_TIMEOUT_MS,
+  maxAttempts = DEFAULT_R2_MAX_ATTEMPTS,
+  delay = sleep2
+} = {}) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const resp = await fetchImpl(uploadUrl, {
+        method: "PUT",
+        headers: {
+          "Content-Type": contentType,
+          "Content-Length": String(fileBuffer.length)
+        },
+        body: fileBuffer,
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (resp.ok) return resp;
+      if (isRetryableStatus(resp.status) && attempt < maxAttempts) {
+        const retryAfter = resp.status === 429 ? parsePositiveInt2(resp.headers.get("retry-after"), null) : null;
+        await delay(getRetryDelayMs(attempt, retryAfter));
+        continue;
+      }
+      throw new Error(`R2 upload failed: ${resp.status}`);
+    } catch (err) {
+      clearTimeout(timeout);
+      const normalizedError = err?.name === "AbortError" ? new Error(`R2 upload timed out after ${Math.ceil(timeoutMs / 1e3)}s`) : err;
+      if (attempt < maxAttempts && isRetryableNetworkError(normalizedError)) {
+        await delay(getRetryDelayMs(attempt));
+        continue;
+      }
+      throw normalizedError;
+    }
+  }
+  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;
@@ -4960,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;
@@ -4988,22 +5276,62 @@ 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) {
-    console.error(import_picocolors9.default.yellow(`  Skipped ${skipped.length} file(s): ${skipped.join(", ")}`));
+    console.error(import_picocolors10.default.yellow(`  Skipped ${skipped.length} file(s): ${skipped.join(", ")}`));
   }
   return files;
 }
-async function stageFiles(paths, opts) {
-  const client = createClient({ accountId: opts.account });
+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)
+  });
   const jsonMode = shouldOutputJson(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);
@@ -5012,97 +5340,111 @@ async function stageFiles(paths, opts) {
     printError("No supported media files found.");
     process.exit(1);
   }
-  if (!jsonMode) {
-    console.log(`
-  ${import_picocolors9.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 uploadedFiles = [];
-  for (let i = 0; i < files.length; i++) {
-    const file = files[i];
+  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_picocolors9.default.dim("\u2192")}  ${import_picocolors9.default.dim(`Uploading ${file.name}...  ${formatSize(file.size)}`)}`);
+      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 resp = await fetch(r2Info.uploadUrl, {
-        method: "PUT",
-        headers: {
-          "Content-Type": file.contentType || (file.type === "video" ? "video/mp4" : "image/jpeg"),
-          "Content-Length": String(fileBuffer.length)
-        },
-        body: fileBuffer
-      });
-      if (!resp.ok) {
-        throw new Error(`R2 upload failed: ${resp.status}`);
-      }
-      uploadedFiles.push({
+      const fileBuffer = import_fs3.default.readFileSync(file.path);
+      await putR2WithRetry(
+        r2Info.uploadUrl,
+        fileBuffer,
+        file.contentType || (file.type === "video" ? "video/mp4" : "image/jpeg"),
+        { 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_picocolors9.default.red("\u2717")}  ${file.name}: ${err.message}`);
+        console.log(`  ${import_picocolors10.default.red("\u2717")}  ${file.name}: ${err.message}`);
       }
-      uploadedFiles.push({ 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_picocolors9.default.dim("\u2192")}  ${import_picocolors9.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++;
         if (!jsonMode) {
           const id = result.videoId || result.mediaHash || "";
-          console.log(`  ${import_picocolors9.default.green("\u2713")}  ${file.name} uploaded successfully  ${import_picocolors9.default.dim(id)}`);
+          console.log(`  ${import_picocolors10.default.green("\u2713")}  ${file.name} uploaded successfully  ${import_picocolors10.default.dim(id)}`);
         }
       } else {
         failed++;
         if (!jsonMode) {
-          console.log(`  ${import_picocolors9.default.red("\u2717")}  ${file.name}: ${result.error}`);
+          console.log(`  ${import_picocolors10.default.red("\u2717")}  ${file.name}: ${result.error}`);
         }
       }
     } catch (err) {
       failed++;
       results.push({ name: file.name, type: file.type, status: "error", error: err.message });
       if (!jsonMode) {
-        console.log(`  ${import_picocolors9.default.red("\u2717")}  ${file.name}: ${err.message}`);
+        console.log(`  ${import_picocolors10.default.red("\u2717")}  ${file.name}: ${err.message}`);
       }
     }
   }
   let groups = [];
-  if (completed > 1) {
+  if (isRetry ? completed >= 1 : completed > 1) {
     try {
       const finalizeResult = await client.uploads.finalize(batchId);
       groups = finalizeResult.groups || [];
@@ -5111,36 +5453,127 @@ 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(`
-  ${import_picocolors9.default.bold("Variant Groups")} (${groups.length})
+  ${import_picocolors10.default.bold("Variant Groups")} (${groups.length})
 `);
     for (const group of groups) {
       const assets = group.assets.map((a) => {
-        const placement = a.placementType === "default" ? "" : import_picocolors9.default.cyan(` [${a.placementType}]`);
+        const placement = a.placementType === "default" ? "" : import_picocolors10.default.cyan(` [${a.placementType}]`);
         return `${a.name}${placement}`;
       });
-      console.log(`  ${import_picocolors9.default.bold(group.baseName || group.groupId)}`);
+      console.log(`  ${import_picocolors10.default.bold(group.baseName || group.groupId)}`);
       for (const asset of assets) {
         console.log(`    ${asset}`);
       }
     }
   }
   console.log(`
-  ${import_picocolors9.default.bold("Batch:")} ${batchId}`);
+  ${import_picocolors10.default.bold("Batch:")} ${batchId}`);
   const countStr = `${completed} complete, ${failed} failed`;
   console.log(`  ${countStr}`);
   if (groups.length > 0) {
-    console.log(`  ${import_picocolors9.default.bold("Groups:")} ${groups.length} variant group(s) detected`);
+    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").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() {
@@ -5155,10 +5588,10 @@ function uploadsCommand() {
       }
       const accountLabel = batch.accountName ? `${batch.accountName} (${batch.accountId})` : batch.accountId;
       console.log(`
-  ${import_picocolors9.default.bold("Batch")} ${batch.batchId}
+  ${import_picocolors10.default.bold("Batch")} ${batch.batchId}
 `);
-      console.log(`  ${import_picocolors9.default.bold("Account:")} ${accountLabel}`);
-      console.log(`  ${import_picocolors9.default.bold("Files:")}   ${batch.total}
+      console.log(`  ${import_picocolors10.default.bold("Account:")} ${accountLabel}`);
+      console.log(`  ${import_picocolors10.default.bold("Files:")}   ${batch.total}
 `);
       const rows = batch.files.map((f) => ({
         ...f,
@@ -5167,19 +5600,19 @@ function uploadsCommand() {
       printTable(rows, [
         { key: "name", label: "Name", maxWidth: 35 },
         { key: "type", label: "Type", maxWidth: 6 },
-        { key: "id", label: "Hash / Video ID", maxWidth: 35, color: (v2) => v2 || import_picocolors9.default.dim("\u2014") }
+        { key: "id", label: "Hash / Video ID", maxWidth: 35, color: (v2) => v2 || import_picocolors10.default.dim("\u2014") }
       ]);
       if (batch.groups?.length > 0) {
         console.log(`
-  ${import_picocolors9.default.bold("Variant Groups")} (${batch.groups.length})
+  ${import_picocolors10.default.bold("Variant Groups")} (${batch.groups.length})
 `);
         for (const group of batch.groups) {
           const primaryAsset = group.assets.find((a) => a.isPrimary);
           const groupLabel = group.baseName || primaryAsset?.name || group.groupId;
-          console.log(`  ${import_picocolors9.default.bold(groupLabel)}`);
+          console.log(`  ${import_picocolors10.default.bold(groupLabel)}`);
           for (const asset of group.assets) {
-            const placement = asset.placementType === "default" ? "" : import_picocolors9.default.cyan(` [${asset.placementType}]`);
-            const primary = asset.isPrimary ? import_picocolors9.default.dim(" (primary)") : "";
+            const placement = asset.placementType === "default" ? "" : import_picocolors10.default.cyan(` [${asset.placementType}]`);
+            const primary = asset.isPrimary ? import_picocolors10.default.dim(" (primary)") : "";
             console.log(`    ${asset.name}${placement}${primary}`);
           }
         }
@@ -5193,10 +5626,10 @@ function uploadsCommand() {
       return;
     }
     console.log(`
-  ${import_picocolors9.default.bold("Recent Uploads")} (${batches.length})
+  ${import_picocolors10.default.bold("Recent Uploads")} (${batches.length})
 `);
     if (batches.length === 0) {
-      console.log(import_picocolors9.default.dim("  No uploads found for this account.\n"));
+      console.log(import_picocolors10.default.dim("  No uploads found for this account.\n"));
       return;
     }
     const formatDate = (d3) => {
@@ -5224,11 +5657,11 @@ function uploadsCommand() {
 }
 
 // src/commands/create.js
-var import_fs3 = __toESM(require("fs"), 1);
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_fs4 = __toESM(require("fs"), 1);
+var import_picocolors12 = __toESM(require_picocolors(), 1);
 
 // src/lib/poll.js
-var import_picocolors10 = __toESM(require_picocolors(), 1);
+var import_picocolors11 = __toESM(require_picocolors(), 1);
 var POLL_INTERVAL = 500;
 var TIMEOUT_MS = 30 * 60 * 1e3;
 var TIMEOUT_MINUTES = TIMEOUT_MS / 6e4;
@@ -5240,7 +5673,7 @@ async function pollJob(client, jobId, opts = {}) {
   if (!jsonMode) {
     if (tty) {
       console.log(`
-  ${import_picocolors10.default.bold("Creating ads")}
+  ${import_picocolors11.default.bold("Creating ads")}
 `);
     } else {
       console.log(`[start] Creating ads \u2014 ${jobId}`);
@@ -5266,7 +5699,7 @@ async function pollJob(client, jobId, opts = {}) {
         process.exitCode = 2;
         return { status: "still_running", jobId };
       }
-      await sleep(POLL_INTERVAL);
+      await sleep3(POLL_INTERVAL);
       continue;
     }
     const ops = data.progress?.operations || [];
@@ -5277,7 +5710,7 @@ async function pollJob(client, jobId, opts = {}) {
         const time = formatTimestamp(op.timestamp);
         const { icon, color } = opStyle(op.type);
         if (tty) {
-          console.log(`  ${import_picocolors10.default.dim(time)}  ${color(icon)}  ${color(op.message)}`);
+          console.log(`  ${import_picocolors11.default.dim(time)}  ${color(icon)}  ${color(op.message)}`);
         } else {
           const tag = op.type === "error" ? "[err]" : op.type === "retry" ? "[..]" : op.type === "completion" || (op.type || "").endsWith("_complete") ? "[ok ]" : "[..]";
           console.log(`${time}  ${tag} ${op.message}`);
@@ -5298,7 +5731,7 @@ async function pollJob(client, jobId, opts = {}) {
         const failed = data.result?.created?.failedAds?.length || 0;
         console.log("");
         if (failed > 0 && adCount > 0) {
-          console.log(`  ${import_picocolors10.default.yellow("\u2212")} ${adCount} ads created, ${failed} failed in ${elapsed}`);
+          console.log(`  ${import_picocolors11.default.yellow("\u2212")} ${adCount} ads created, ${failed} failed in ${elapsed}`);
         } else if (adCount > 0) {
           printSuccess(`Created ${adCount} ads in ${elapsed}`);
         } else {
@@ -5313,14 +5746,14 @@ async function pollJob(client, jobId, opts = {}) {
         console.log(JSON.stringify({ event: "still_running", jobId }));
       } else {
         console.log("");
-        console.log(`  ${import_picocolors10.default.yellow("\u2212")}  ${import_picocolors10.default.yellow(`Still running after ${TIMEOUT_MINUTES} min \u2014 job continues on the server.`)}`);
-        console.log(`     Resume with: ${import_picocolors10.default.bold(`ads jobs ${jobId} --follow`)}`);
+        console.log(`  ${import_picocolors11.default.yellow("\u2212")}  ${import_picocolors11.default.yellow(`Still running after ${TIMEOUT_MINUTES} min \u2014 job continues on the server.`)}`);
+        console.log(`     Resume with: ${import_picocolors11.default.bold(`ads jobs ${jobId} --follow`)}`);
         console.log("");
       }
       process.exitCode = 2;
       return { status: "still_running", jobId };
     }
-    await sleep(POLL_INTERVAL);
+    await sleep3(POLL_INTERVAL);
   }
 }
 function opStyle(type) {
@@ -5328,13 +5761,13 @@ function opStyle(type) {
     case "completion":
     case "campaign_complete":
     case "adset_complete":
-      return { icon: "\u2713", color: import_picocolors10.default.green };
+      return { icon: "\u2713", color: import_picocolors11.default.green };
     case "error":
-      return { icon: "\u2717", color: import_picocolors10.default.red };
+      return { icon: "\u2717", color: import_picocolors11.default.red };
     case "retry":
-      return { icon: "\u2212", color: import_picocolors10.default.yellow };
+      return { icon: "\u2212", color: import_picocolors11.default.yellow };
     default:
-      return { icon: "\u2192", color: import_picocolors10.default.dim };
+      return { icon: "\u2192", color: import_picocolors11.default.dim };
   }
 }
 function formatTimestamp(iso) {
@@ -5346,7 +5779,7 @@ function formatTimestamp(iso) {
     return "        ";
   }
 }
-function sleep(ms) {
+function sleep3(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
@@ -5370,29 +5803,29 @@ async function executeCreate(body, opts, { preview = false, test = false } = {})
       const ts = result.totalAdSets || 1;
       const ta = result.totalAds || result.ads?.length || 0;
       const parts = [];
-      if (tc > 1) parts.push(`${import_picocolors11.default.blue(tc)} campaigns`);
-      parts.push(`${import_picocolors11.default.blue(ts)} ad set${ts !== 1 ? "s" : ""}`);
-      parts.push(`${import_picocolors11.default.blue(ta)} ad${ta !== 1 ? "s" : ""}`);
+      if (tc > 1) parts.push(`${import_picocolors12.default.blue(tc)} campaigns`);
+      parts.push(`${import_picocolors12.default.blue(ts)} ad set${ts !== 1 ? "s" : ""}`);
+      parts.push(`${import_picocolors12.default.blue(ta)} ad${ta !== 1 ? "s" : ""}`);
       let statusStr = statusColor(result.status || "PAUSED");
       if (result.status === "PAUSED" && result.pauseAt && result.pauseAt !== "ad") {
         const levelLabel = result.pauseAt === "campaign" ? "campaign level" : "ad set level";
-        statusStr += import_picocolors11.default.dim(` (${levelLabel})`);
+        statusStr += import_picocolors12.default.dim(` (${levelLabel})`);
       }
       let enhLabel = "";
-      if (result.enhancements === "metaDefaults") enhLabel = import_picocolors11.default.dim("All Off");
-      else if (result.enhancements === "all") enhLabel = import_picocolors11.default.dim("All On");
-      else if (result.enhancements === "none") enhLabel = import_picocolors11.default.dim("All Off");
-      else if (Array.isArray(result.enhancements)) enhLabel = import_picocolors11.default.dim(`${result.enhancements.length} custom`);
-      const enhPart = enhLabel ? ` ${import_picocolors11.default.dim("\xB7")} ${enhLabel}` : "";
-      console.log(`  ${parts.join(", ")} ${import_picocolors11.default.dim("\xB7")} ${statusStr}${enhPart}
+      if (result.enhancements === "metaDefaults") enhLabel = import_picocolors12.default.dim("All Off");
+      else if (result.enhancements === "all") enhLabel = import_picocolors12.default.dim("All On");
+      else if (result.enhancements === "none") enhLabel = import_picocolors12.default.dim("All Off");
+      else if (Array.isArray(result.enhancements)) enhLabel = import_picocolors12.default.dim(`${result.enhancements.length} custom`);
+      const enhPart = enhLabel ? ` ${import_picocolors12.default.dim("\xB7")} ${enhLabel}` : "";
+      console.log(`  ${parts.join(", ")} ${import_picocolors12.default.dim("\xB7")} ${statusStr}${enhPart}
 `);
       if (result.ads?.length) {
         const tableRows = [];
         let lastCampaign = null;
         let lastAdSet = null;
         for (const ad of result.ads) {
-          const campaignName = ad.campaignName || import_picocolors11.default.dim("\u2014");
-          const adSetName = ad.adSetName || import_picocolors11.default.dim("\u2014");
+          const campaignName = ad.campaignName || import_picocolors12.default.dim("\u2014");
+          const adSetName = ad.adSetName || import_picocolors12.default.dim("\u2014");
           tableRows.push({
             campaign: campaignName === lastCampaign ? "" : campaignName,
             adSet: campaignName === lastCampaign && adSetName === lastAdSet ? "" : adSetName,
@@ -5440,54 +5873,61 @@ async function executeCreate(body, opts, { preview = false, test = false } = {})
         for (const ad of result.ads) {
           if (showAdSetHeaders && ad.adSetName && ad.adSetName !== lastDetailAdSet) {
             if (lastDetailAdSet !== null) console.log("");
-            console.log(`  ${import_picocolors11.default.dim("\u25B8 Ad Set:")} ${import_picocolors11.default.bold(ad.adSetName)}`);
+            console.log(`  ${import_picocolors12.default.dim("\u25B8 Ad Set:")} ${import_picocolors12.default.bold(ad.adSetName)}`);
             lastDetailAdSet = ad.adSetName;
           }
-          const typeLabel = ad.mediaType ? import_picocolors11.default.dim(` [${ad.mediaType}]`) : "";
+          const typeLabel = ad.mediaType ? import_picocolors12.default.dim(` [${ad.mediaType}]`) : "";
           const indent = showAdSetHeaders ? "    " : "  ";
           const fieldIndent = showAdSetHeaders ? "      " : "    ";
           const fieldIndentLen = fieldIndent.length;
-          console.log(`${indent}${import_picocolors11.default.bold(import_picocolors11.default.blue(ad.name))}${typeLabel}`);
+          console.log(`${indent}${import_picocolors12.default.bold(import_picocolors12.default.blue(ad.name))}${typeLabel}`);
           const headline = (ad.headline || []).join(" | ");
           const primary = (ad.primaryText || []).join(" | ");
           const desc = (ad.description || []).join(" | ");
-          if (headline) console.log(`${fieldIndent}${import_picocolors11.default.dim("Headline:")}      ${trunc(headline)}`);
-          if (primary) console.log(`${fieldIndent}${import_picocolors11.default.dim("Primary Text:")}  ${trunc(primary)}`);
-          if (desc) console.log(`${fieldIndent}${import_picocolors11.default.dim("Description:")}   ${trunc(desc)}`);
-          if (ad.cta && !sharedCta) console.log(`${fieldIndent}${import_picocolors11.default.dim("CTA:")}           ${ad.cta}`);
-          if (ad.link && !sharedLink) console.log(`${fieldIndent}${import_picocolors11.default.dim("Link:")}          ${wrapLine(ad.link, fieldIndentLen)}`);
-          if (ad.urlTags && !sharedUrlTags) console.log(`${fieldIndent}${import_picocolors11.default.dim("URL Tags:")}     ${wrapLine(ad.urlTags, fieldIndentLen)}`);
+          if (headline) console.log(`${fieldIndent}${import_picocolors12.default.dim("Headline:")}      ${trunc(headline)}`);
+          if (primary) console.log(`${fieldIndent}${import_picocolors12.default.dim("Primary Text:")}  ${trunc(primary)}`);
+          if (desc) console.log(`${fieldIndent}${import_picocolors12.default.dim("Description:")}   ${trunc(desc)}`);
+          if (ad.cta && !sharedCta) console.log(`${fieldIndent}${import_picocolors12.default.dim("CTA:")}           ${ad.cta}`);
+          if (ad.link && !sharedLink) console.log(`${fieldIndent}${import_picocolors12.default.dim("Link:")}          ${wrapLine(ad.link, fieldIndentLen)}`);
+          if (ad.urlTags && !sharedUrlTags) console.log(`${fieldIndent}${import_picocolors12.default.dim("URL Tags:")}     ${wrapLine(ad.urlTags, fieldIndentLen)}`);
           console.log("");
         }
         const valCol = 18;
-        if (sharedCta) console.log(`  ${import_picocolors11.default.bold("CTA:")}            ${sharedCta}`);
-        if (sharedLink) console.log(`  ${import_picocolors11.default.bold("Link:")}           ${wrapLine(sharedLink, valCol)}`);
-        if (sharedUrlTags) console.log(`  ${import_picocolors11.default.bold("URL Tags:")}       ${wrapLine(sharedUrlTags, valCol)}`);
+        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";
         else if (enh === "all") enhDetail = "All On";
         else if (enh === "none") enhDetail = "All Off";
         else if (Array.isArray(enh)) enhDetail = enh.join(", ");
-        if (enhDetail) console.log(`  ${import_picocolors11.default.bold("Enhancements:")}   ${wrapLine(enhDetail, valCol)}`);
+        if (enhDetail) console.log(`  ${import_picocolors12.default.bold("Enhancements:")}   ${wrapLine(enhDetail, valCol)}`);
         if (result.budget) {
           const curr = result.budget.currency ? ` ${result.budget.currency}` : "";
           const renderLine = (label, amount) => {
             const pad = " ".repeat(Math.max(1, 16 - label.length - 1));
-            console.log(`  ${import_picocolors11.default.bold(`${label}:`)}${pad}${amount}${curr}`);
+            console.log(`  ${import_picocolors12.default.bold(`${label}:`)}${pad}${amount}${curr}`);
           };
           if (result.budget.dailyBudget != null) renderLine("Daily Budget", result.budget.dailyBudget);
           if (result.budget.bidAmount != null) renderLine("Bid Amount", result.budget.bidAmount);
         }
         console.log("");
       } else if (result.plan?.totals) {
-        console.log(`  ${import_picocolors11.default.bold("Plan:")}`);
+        console.log(`  ${import_picocolors12.default.bold("Plan:")}`);
         console.log(`    Campaigns: ${result.plan.totals.campaigns}`);
         console.log(`    Ad Sets:   ${result.plan.totals.adSets}`);
         console.log(`    Ads:       ${result.plan.totals.ads}`);
       }
       console.log(`
-  ${import_picocolors11.default.dim("This is a preview. No ads were created.")}
+  ${import_picocolors12.default.dim("This is a preview. No ads were created.")}
 `);
       return;
     }
@@ -5508,13 +5948,13 @@ async function executeCreate(body, opts, { preview = false, test = false } = {})
     printSuccess(`${result.status || "Complete"}`);
     if (result.result?.created?.ads?.length) {
       console.log(`
-  ${import_picocolors11.default.bold("Created:")} ${result.result.created.ads.length} ad(s)`);
+  ${import_picocolors12.default.bold("Created:")} ${result.result.created.ads.length} ad(s)`);
     }
     console.log("");
   } catch (err) {
     printError(err.message);
     if (err.details) {
-      console.error(import_picocolors11.default.dim(`  Details: ${JSON.stringify(err.details)}`));
+      console.error(import_picocolors12.default.dim(`  Details: ${JSON.stringify(err.details)}`));
     }
     process.exit(1);
   }
@@ -5536,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}`);
@@ -5550,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);
@@ -5575,6 +6015,14 @@ function buildBodyFromOpts(specFile, opts) {
     body.adSet = body.adSet || {};
     body.adSet.bidAmount = bid;
   }
+  if (opts.page || opts.instagram || opts.threads) {
+    body.profile = {
+      ...body.profile || {},
+      ...opts.page ? { pageId: opts.page } : {},
+      ...opts.instagram ? { instagramId: opts.instagram } : {},
+      ...opts.threads ? { threadsId: opts.threads } : {}
+    };
+  }
   if (opts.pauseAt) {
     if (!["ad", "adSet", "campaign"].includes(opts.pauseAt)) {
       printError('--pause-at must be "ad", "adSet", or "campaign"');
@@ -5585,7 +6033,7 @@ function buildBodyFromOpts(specFile, opts) {
   }
   return body;
 }
-var sharedOpts = (cmd) => cmd.option("--account <id>", "Ad account ID").option("--preset <id>", "API preset ID").option("--text-preset <id>", "Text preset ID").option("--copy-from <adId>", "Ad ID to copy settings from").option("--upload <batchId>", "Upload batch ID").option("--status <status>", "PAUSED or ACTIVE (default: ACTIVE)").option("--daily-budget <amount>", "Override daily budget per ad set (in currency units, e.g. 50 for $50)").option("--bid-amount <amount>", "Override bid/cost cap per ad set (in currency units, e.g. 5 for $5)").option("--pause-at <level>", "Pause level: ad (default), adSet, or campaign").option("--text-file <path>", "Load text configuration from JSON file").option("--expanded", "Show full headline / primary text / description without truncation").option("--json", "Output as JSON");
+var sharedOpts = (cmd) => cmd.option("--account <id>", "Ad account ID").option("--preset <id>", "API preset ID").option("--text-preset <id>", "Text preset ID").option("--copy-from <adId>", "Ad ID to copy settings from").option("--upload <batchId>", "Upload batch ID").option("--status <status>", "PAUSED or ACTIVE (default: ACTIVE)").option("--daily-budget <amount>", "Override daily budget per ad set (in currency units, e.g. 50 for $50)").option("--bid-amount <amount>", "Override bid/cost cap per ad set (in currency units, e.g. 5 for $5)").option("--pause-at <level>", "Pause level: ad (default), adSet, or campaign").option("--page <id>", "Override Facebook Page ID for created ads").option("--instagram <id>", "Override Instagram account ID for created ads").option("--threads <id>", "Override Threads profile ID for created ads").option("--text-file <path>", "Load text configuration from JSON file").option("--expanded", "Show full headline / primary text / description without truncation").option("--json", "Output as JSON");
 function createCommand2() {
   const cmd = new Command("create").description("Create ads from spec file or flags").argument("[specFile]", "JSON spec file with ad configuration");
   sharedOpts(cmd);
@@ -5627,7 +6075,7 @@ async function interactiveCreate(client) {
     printError("Interactive mode requires a TTY. Use a spec file or flags instead.");
     process.exit(1);
   }
-  Ie(import_picocolors11.default.bold("Ads Uploader \u2014 Create Ads"));
+  Ie(import_picocolors12.default.bold("Ads Uploader \u2014 Create Ads"));
   if (!client.accountId) {
     const { accounts } = await client.accounts.list();
     const accountChoice = await ve({
@@ -5764,7 +6212,7 @@ async function interactiveCreate(client) {
     });
     if (pD(namePattern)) process.exit(0);
     body.adNamePattern = namePattern;
-    M2.info(import_picocolors11.default.dim("Variables: {filename}, {index:01}, {variation}, {campaign}, {date}, {timestamp}"));
+    M2.info(import_picocolors12.default.dim("Variables: {filename}, {index:01}, {variation}, {campaign}, {date}, {timestamp}"));
   }
   const textMethod = await ve({
     message: "Ad text",
@@ -5796,7 +6244,7 @@ async function interactiveCreate(client) {
       ]
     });
     if (pD(textStrategy)) process.exit(0);
-    M2.info(import_picocolors11.default.dim("Enter headlines (one per line). Leave blank and press enter to finish."));
+    M2.info(import_picocolors12.default.dim("Enter headlines (one per line). Leave blank and press enter to finish."));
     const headlines = [];
     for (; ; ) {
       const h2 = await he({
@@ -5807,7 +6255,7 @@ async function interactiveCreate(client) {
       if (!h2) break;
       headlines.push(h2);
     }
-    M2.info(import_picocolors11.default.dim("Enter primary text (one per line). Leave blank to finish."));
+    M2.info(import_picocolors12.default.dim("Enter primary text (one per line). Leave blank to finish."));
     const bodies = [];
     for (; ; ) {
       const b4 = await he({
@@ -5916,7 +6364,7 @@ async function interactiveCreate(client) {
     }
   }
   console.log("");
-  M2.info(import_picocolors11.default.bold("Summary"));
+  M2.info(import_picocolors12.default.bold("Summary"));
   if (body.adPresetId) M2.info(`  Preset: ${body.adPresetId}`);
   if (body.copyFromAd) M2.info(`  Copy from: ${body.copyFromAd}`);
   M2.info(`  Upload: ${body.uploadId}`);
@@ -5938,13 +6386,13 @@ async function interactiveCreate(client) {
 }
 
 // src/commands/jobs.js
-var import_picocolors12 = __toESM(require_picocolors(), 1);
+var import_picocolors13 = __toESM(require_picocolors(), 1);
 function jobsCommand() {
   const cmd = new Command("jobs").description("Manage ad creation jobs").option("--json", "Output as JSON").option("--follow", "Follow job progress in real-time").argument("[jobId]", "Job ID to check status").action(async (jobId, opts) => {
     if (!jobId) {
-      console.log(import_picocolors12.default.dim("  Usage: ads jobs <jobId>"));
-      console.log(import_picocolors12.default.dim("         ads jobs <jobId> --follow"));
-      console.log(import_picocolors12.default.dim("         ads jobs cancel <jobId>"));
+      console.log(import_picocolors13.default.dim("  Usage: ads jobs <jobId>"));
+      console.log(import_picocolors13.default.dim("         ads jobs <jobId> --follow"));
+      console.log(import_picocolors13.default.dim("         ads jobs cancel <jobId>"));
       return;
     }
     const client = createClient({});
@@ -5958,16 +6406,16 @@ function jobsCommand() {
       return;
     }
     console.log(`
-  ${import_picocolors12.default.bold("Job")} ${jobId}
+  ${import_picocolors13.default.bold("Job")} ${jobId}
 `);
-    console.log(`  ${import_picocolors12.default.bold("Status:")}    ${statusLabel(result.status)}`);
-    console.log(`  ${import_picocolors12.default.bold("Complete:")}  ${result.complete ? import_picocolors12.default.green("yes") : import_picocolors12.default.yellow("no")}`);
+    console.log(`  ${import_picocolors13.default.bold("Status:")}    ${statusLabel(result.status)}`);
+    console.log(`  ${import_picocolors13.default.bold("Complete:")}  ${result.complete ? import_picocolors13.default.green("yes") : import_picocolors13.default.yellow("no")}`);
     if (result.progress) {
       const prog = result.progress;
-      console.log(`  ${import_picocolors12.default.bold("Progress:")}  ${prog.completed || 0}/${prog.total || "?"}`);
+      console.log(`  ${import_picocolors13.default.bold("Progress:")}  ${prog.completed || 0}/${prog.total || "?"}`);
     }
     if (result.error) {
-      console.log(`  ${import_picocolors12.default.bold("Error:")}     ${import_picocolors12.default.red(result.error.message || result.error)}`);
+      console.log(`  ${import_picocolors13.default.bold("Error:")}     ${import_picocolors13.default.red(result.error.message || result.error)}`);
     }
     console.log("");
   });
@@ -5988,27 +6436,27 @@ function jobsCommand() {
 function statusLabel(status) {
   switch (status) {
     case "complete":
-      return import_picocolors12.default.green("Complete");
+      return import_picocolors13.default.green("Complete");
     case "running":
     case "in_progress":
-      return import_picocolors12.default.cyan("Running");
+      return import_picocolors13.default.cyan("Running");
     case "cancelled":
-      return import_picocolors12.default.yellow("Cancelled");
+      return import_picocolors13.default.yellow("Cancelled");
     case "error":
     case "failed":
-      return import_picocolors12.default.red("Failed");
+      return import_picocolors13.default.red("Failed");
     default:
-      return import_picocolors12.default.dim(status || "unknown");
+      return import_picocolors13.default.dim(status || "unknown");
   }
 }
 
 // src/cli.js
-var VERSION = true ? "0.1.8" : "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";
 }
-var b3 = (s) => import_picocolors13.default.bold(import_picocolors13.default.blue(s));
+var b3 = (s) => import_picocolors14.default.bold(import_picocolors14.default.blue(s));
 var BANNER = [
   "",
   "  " + b3("   ___     __      __  __     __             __"),
@@ -6017,7 +6465,7 @@ var BANNER = [
   "  " + b3("/_/ |_\\_,_/___/  \\____/ .__/_/\\___/\\_,_/\\_,_/\\__/_/"),
   "  " + b3("                     /_/"),
   "",
-  "  " + import_picocolors13.default.dim("Create Meta ads from the command line"),
+  "  " + import_picocolors14.default.dim("Create Meta ads from the command line"),
   ""
 ].join("\n");
 var program2 = new Command().name("ads").description("Ads Uploader CLI").version(VERSION).addHelpText("before", BANNER);
@@ -6027,6 +6475,7 @@ program2.addCommand(whoamiCommand());
 program2.addCommand(configCommand());
 program2.addCommand(accountsCommand());
 program2.addCommand(accountCommand());
+program2.addCommand(pagesCommand());
 program2.addCommand(campaignsCommand());
 program2.addCommand(campaignCommand());
 program2.addCommand(adsetsCommand());
@@ -6044,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 {
     }
@@ -6058,14 +6507,14 @@ 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) {
       console.error(`
-  ${import_picocolors13.default.yellow("Update available:")} ${import_picocolors13.default.dim(VERSION)} \u2192 ${import_picocolors13.default.green(latest)}`);
-      console.error(`  Run ${import_picocolors13.default.cyan("npm update -g @adsuploader/cli")} to update
+  ${import_picocolors14.default.yellow("Update available:")} ${import_picocolors14.default.dim(VERSION)} \u2192 ${import_picocolors14.default.green(latest)}`);
+      console.error(`  Run ${import_picocolors14.default.cyan("npm update -g @adsuploader/cli")} to update
 `);
     }
   } catch {
@@ -6089,7 +6538,7 @@ if (process.argv.length <= 2) {
     }
     if (err.code !== "commander.executeSubCommandAsync") {
       console.error(`
-  ${import_picocolors13.default.red("Error:")} ${err.message}
+  ${import_picocolors14.default.red("Error:")} ${err.message}
 `);
       process.exit(1);
     }