@spark-apps/quickpeek 1.1.2 → 1.2.0

package/dist/qp.js

@@ -35,14 +35,6 @@ function getLanguageName(lang) {
   if (!lang || lang === "en") return null;
   return LANGUAGE_NAMES[lang] || lang.toUpperCase();
 }
-function hexToASS(hex, alpha = 0) {
-  const clean = hex.replace("#", "");
-  const r = clean.slice(0, 2);
-  const g = clean.slice(2, 4);
-  const b = clean.slice(4, 6);
-  const a = alpha.toString(16).padStart(2, "0").toUpperCase();
-  return `&H${a}${b}${g}${r}`.toUpperCase();
-}
 function rgbaToHex(color) {
   if (color.startsWith("#")) return color;
   const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
@@ -52,12 +44,6 @@ function rgbaToHex(color) {
   const b = parseInt(match[3], 10).toString(16).padStart(2, "0");
   return `#${r}${g}${b}`.toUpperCase();
 }
-function windowsPathToWSL(path) {
-  const driveMatch = /^([A-Z]):[/\\]/i.exec(path);
-  if (!driveMatch) return null;
-  const drive = driveMatch[1].toLowerCase();
-  return `/mnt/${drive}/${path.slice(3).replace(/\\/g, "/")}`;
-}
 function parsePartial(partial) {
   if (!partial) return {};
   const parts = partial.split("-");
@@ -83,10 +69,12 @@ function toTitleCase(text) {
     return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
   });
 }
-var LANGUAGE_NAMES, LOWERCASE_WORDS;
+var import_video_kit, import_video_kit2, LANGUAGE_NAMES, LOWERCASE_WORDS;
 var init_utils = __esm({
   "src/lib/utils.ts"() {
     "use strict";
+    import_video_kit = require("@spark-apps/video-kit");
+    import_video_kit2 = require("@spark-apps/video-kit");
     LANGUAGE_NAMES = {
       ar: "Arabic",
       es: "Spanish",
@@ -137,123 +125,186 @@ var init_utils = __esm({
 });
 
 // src/lib/api-client.ts
-function hasCredentials() {
-  return Boolean(process.env[ENV_SPARK_API_KEY]);
-}
-function getGroqApiKey() {
-  return process.env[ENV_SPARK_API_KEY] || null;
-}
-function getStripeUrl() {
-  return process.env[ENV_STRIPE_BACKEND] || DEFAULT_STRIPE_BACKEND;
-}
-async function getOrRefreshToken(apiKey) {
+async function getOrRefreshDirectToken() {
   const now = Date.now();
-  if (cachedToken && cachedToken.expiresAt > now + 3e5) {
-    return cachedToken.token;
+  if (cachedDirectToken && cachedDirectToken.expiresAt > now + 3e5) {
+    return cachedDirectToken.token;
   }
   try {
     const response = await fetch(SPARK_AI_TOKEN, {
       method: "POST",
-      headers: { "X-Api-Key": apiKey }
+      headers: { "X-Api-Key": API_KEY }
     });
+    if (!response.ok) {
+      throw new Error(`Token exchange failed: ${response.status} ${response.statusText}`);
+    }
     const data = await response.json();
-    if (!response.ok || !data.success || !data.token) {
-      throw new Error(data.error || `Token exchange failed: ${response.status}`);
+    if (!data.success || !data.token) {
+      throw new Error(data.error || `Token exchange failed: unexpected response`);
     }
-    cachedToken = {
+    cachedDirectToken = {
       token: data.token,
       expiresAt: data.expiresAt || now + 36e5
-      // Default 1 hour
     };
     return data.token;
   } catch (err) {
     throw new Error(`Failed to get Spark AI token: ${getErrorMessage(err)}`);
   }
 }
-async function callAI(systemPrompt, userPrompt, tier = "free") {
-  const apiKey = getGroqApiKey();
-  if (!apiKey) {
-    return {
-      success: false,
-      error: `Missing API key. Set ${ENV_SPARK_API_KEY} environment variable.`,
-      isAuthError: true
-    };
+async function getOrRefreshRelayToken(email) {
+  const now = Date.now();
+  if (cachedRelayToken && cachedRelayToken.email === email && cachedRelayToken.expiresAt > now + 3e5) {
+    return cachedRelayToken.token;
   }
   try {
-    const token = await getOrRefreshToken(apiKey);
-    let lastRateLimitError = null;
-    for (let attempt = 1; attempt <= 3; attempt++) {
-      try {
-        const response = await fetch(SPARK_AI_CHAT, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`
-          },
-          body: JSON.stringify({
-            messages: [
-              { role: "system", content: systemPrompt },
-              { role: "user", content: userPrompt }
-            ]
-          })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          const error = data.error || `Spark AI error: ${response.status}`;
-          if (response.status === 429 && attempt < 3) {
-            const retryAfter = response.headers.get("Retry-After");
-            const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 1e3 * Math.pow(2, attempt - 1);
-            lastRateLimitError = {
-              success: false,
-              error,
-              isRateLimit: true,
-              retryAfterSeconds: retryAfter ? parseInt(retryAfter, 10) : void 0
-            };
-            await new Promise((resolve9) => setTimeout(resolve9, Math.min(delayMs, 3e4)));
-            continue;
-          }
-          return {
+    const response = await fetch(RELAY_TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email })
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok || !data.success || !data.token) {
+      throw new Error(data.error || `Token request failed: ${response.status} ${response.statusText}`);
+    }
+    cachedRelayToken = {
+      token: data.token,
+      expiresAt: data.expiresAt || now + 36e5,
+      email
+    };
+    return data.token;
+  } catch (err) {
+    throw new Error(`Failed to get QuickPeek token: ${getErrorMessage(err)}`);
+  }
+}
+async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier) {
+  let lastRateLimitError = null;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const response = await fetch(chatUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${bearerToken}`
+        },
+        body: JSON.stringify({
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userPrompt }
+          ]
+        })
+      });
+      let data = {};
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json")) {
+        data = await response.json();
+      }
+      if (!response.ok) {
+        const error = data.error || `Spark AI error: ${response.status} ${response.statusText}`;
+        if (response.status === 429 && attempt < 3) {
+          const retryAfter = response.headers.get("Retry-After");
+          const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 1e3 * 2 ** (attempt - 1);
+          lastRateLimitError = {
             success: false,
             error,
-            isRateLimit: response.status === 429,
-            isAuthError: response.status === 401 || response.status === 403
-          };
-        }
-        if (!data.success || !data.response) {
-          return {
-            success: false,
-            error: data.error || "No response from Spark AI"
+            isRateLimit: true,
+            ...retryAfter ? { retryAfterSeconds: parseInt(retryAfter, 10) } : {}
           };
+          await new Promise((resolve9) => setTimeout(resolve9, Math.min(delayMs, 3e4)));
+          continue;
         }
         return {
-          success: true,
-          content: data.response,
-          limits: {
-            used: data.limits?.used ?? 0,
-            limit: data.limits?.limit ?? 100,
-            tier,
-            resetAt: data.limits?.resetAt
-          }
+          success: false,
+          error,
+          isRateLimit: response.status === 429,
+          isAuthError: response.status === 401 || response.status === 403
+        };
+      }
+      if (!data.success || !data.response) {
+        return {
+          success: false,
+          error: data.error || "No response from Spark AI"
         };
-      } catch (err) {
-        if (attempt === 3) throw err;
-        const delayMs = 1e3 * Math.pow(2, attempt - 1);
-        await new Promise((resolve9) => setTimeout(resolve9, delayMs));
       }
+      return {
+        success: true,
+        content: data.response,
+        limits: {
+          used: data.limits?.used ?? 0,
+          limit: data.limits?.limit ?? 100,
+          tier,
+          ...data.limits?.resetAt ? { resetAt: data.limits.resetAt } : {}
+        }
+      };
+    } catch (err) {
+      if (attempt === 3) throw err;
+      const delayMs = 1e3 * 2 ** (attempt - 1);
+      await new Promise((resolve9) => setTimeout(resolve9, delayMs));
     }
-    return lastRateLimitError || { success: false, error: "Request failed after retries" };
+  }
+  return lastRateLimitError || { success: false, error: "Request failed after retries" };
+}
+async function callAI(systemPrompt, userPrompt, tier = "free") {
+  if (!API_KEY) {
+    return {
+      success: false,
+      error: "AI service is not configured. Please report this issue.",
+      isAuthError: true
+    };
+  }
+  try {
+    const token = await getOrRefreshDirectToken();
+    return await executeChat(SPARK_AI_CHAT, token, systemPrompt, userPrompt, tier);
+  } catch (err) {
+    return { success: false, error: `Spark AI error: ${getErrorMessage(err)}` };
+  }
+}
+async function callAIViaRelay(systemPrompt, userPrompt, email, tier = "free") {
+  if (!email) {
+    return {
+      success: false,
+      error: "Sign in required. Run qp login to connect your account.",
+      isAuthError: true
+    };
+  }
+  try {
+    let token = await getOrRefreshRelayToken(email);
+    let result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier);
+    if (!result.success && result.isAuthError) {
+      cachedRelayToken = null;
+      token = await getOrRefreshRelayToken(email);
+      result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier);
+    }
+    return result;
   } catch (err) {
     return { success: false, error: `Spark AI error: ${getErrorMessage(err)}` };
   }
 }
-function getBackendUrls() {
-  return { stripe: getStripeUrl() };
+function parseAIPlanResponse(content) {
+  try {
+    let processedContent = content;
+    const codeBlockMatch = processedContent.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (codeBlockMatch?.[1]) {
+      processedContent = codeBlockMatch[1].trim();
+    }
+    const jsonMatch = processedContent.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return { success: false, error: "No valid JSON found in AI response" };
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    return { success: true, plan: parsed };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to parse AI response: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
 }
-function getCredentials() {
-  const key = getGroqApiKey();
-  return key ? { apiKey: key } : null;
+function normalizeUrl(input) {
+  let url = input.trim();
+  url = url.replace(/^(https?:\/\/)?(www\.)?/i, "");
+  return `https://${url}`;
 }
-var SPARK_AI_BASE, SPARK_AI_CHAT, SPARK_AI_TOKEN, ENV_SPARK_API_KEY, ENV_STRIPE_BACKEND, DEFAULT_STRIPE_BACKEND, cachedToken;
+var SPARK_AI_BASE, SPARK_AI_CHAT, SPARK_AI_TOKEN, RELAY_BASE, RELAY_TOKEN_URL, RELAY_CHAT_URL, API_KEY, cachedDirectToken, cachedRelayToken;
 var init_api_client = __esm({
   "src/lib/api-client.ts"() {
     "use strict";
@@ -261,10 +312,91 @@ var init_api_client = __esm({
     SPARK_AI_BASE = "https://sparkbrain.app";
     SPARK_AI_CHAT = `${SPARK_AI_BASE}/api/chat`;
     SPARK_AI_TOKEN = `${SPARK_AI_BASE}/api/models/token`;
-    ENV_SPARK_API_KEY = "SPARK_API_KEY";
-    ENV_STRIPE_BACKEND = "QP_STRIPE_BACKEND";
-    DEFAULT_STRIPE_BACKEND = "https://sparkstripe.com";
-    cachedToken = null;
+    RELAY_BASE = process.env.QUICKPEEK_API_BASE || "https://quickpeek.co";
+    RELAY_TOKEN_URL = `${RELAY_BASE}/api/cli/token`;
+    RELAY_CHAT_URL = `${RELAY_BASE}/api/cli/ai`;
+    API_KEY = process.env.SPARK_AI_KEY || "";
+    cachedDirectToken = null;
+    cachedRelayToken = null;
+  }
+});
+
+// src/lib/SparkStripe-feature-gating.ts
+async function _fetch(email, init) {
+  const r = await fetch(
+    `${BASE}/api/public/subscription/status-public?email=${encodeURIComponent(email)}&app_id=${APP_ID}`,
+    init
+  );
+  if (!r.ok) throw new Error(`spark-stripe: ${r.status}`);
+  return r.json();
+}
+async function getStatusCached(email) {
+  const k = email.toLowerCase(), hit = _cache.get(k);
+  if (hit && Date.now() < hit.exp) return hit.data;
+  const data = await getStatus(email);
+  _cache.set(k, { data, exp: Date.now() + 6e4 });
+  return data;
+}
+function getTier(d) {
+  if (!d.subscription || !d.registered) return "free";
+  if (d.subscription.status === "canceled" || d.subscription.status === "past_due") return "free";
+  return TIERS[d.subscription.price_id] ?? "free";
+}
+async function getTierByEmail(email) {
+  try {
+    return getTier(await getStatusCached(email));
+  } catch {
+    return "free";
+  }
+}
+async function isVerified(email) {
+  try {
+    return (await getStatusCached(email)).verified;
+  } catch {
+    return false;
+  }
+}
+function pricingUrl(opts) {
+  const u = new URL(`${BASE}/pricing/${APP_ID}`);
+  if (opts?.email) u.searchParams.set("email", opts.email);
+  if (opts?.returnUrl) u.searchParams.set("return_url", opts.returnUrl);
+  return u.toString();
+}
+var APP_ID, BASE, TIERS, RANK, FEATURES, getStatus, _cache, isPaid, hasAccess, hasTrialRemaining, showPaywall, isCanceling;
+var init_SparkStripe_feature_gating = __esm({
+  "src/lib/SparkStripe-feature-gating.ts"() {
+    "use strict";
+    APP_ID = process.env.SPARK_APP_ID ?? "quickpeek";
+    BASE = "https://sparkstripe.com";
+    TIERS = {
+      price_1TADnPEf9opkuWid9NtqOYON: "pro",
+      price_1TADnPEf9opkuWidgbvvX9ma: "pro",
+      price_1TADm7Ef9opkuWid3I9tquIB: "pro",
+      price_1TADm8Ef9opkuWid1RSA2wCa: "pro",
+      price_1TCREmEf9opkuWidvhuqzqDM: "pro",
+      price_1TCREmEf9opkuWidacf1tiC7: "pro"
+    };
+    RANK = {
+      free: 0,
+      pro: 1
+    };
+    FEATURES = {
+      free: [],
+      pro: [
+        "Everything in Free",
+        "No watermark",
+        "Full video composition (voiceover + captions + music + transitions)",
+        "Unlimited videos",
+        "Priority support"
+      ]
+    };
+    getStatus = (email) => _fetch(email);
+    _cache = /* @__PURE__ */ new Map();
+    isPaid = (d) => getTier(d) !== "free";
+    hasAccess = (d, min) => (RANK[getTier(d)] ?? 0) >= (RANK[min] ?? 0);
+    hasTrialRemaining = (d) => isPaid(d) || !!d.trial && !d.trial.is_expired && d.trial.uses_remaining > 0;
+    showPaywall = (d) => !isPaid(d) && !hasTrialRemaining(d);
+    isCanceling = (d) => !!d.subscription && d.subscription.cancel_at_period_end && d.subscription.status !== "canceled";
   }
 });
 
@@ -273,17 +405,12 @@ function shouldWatermark(tier, videoDurationSeconds) {
   return tier === "free" && videoDurationSeconds > 20;
 }
 function getUpgradeUrl(userEmail) {
-  const stripe = getStripeUrl();
-  let url = `${stripe}/pricing/quickpeek`;
-  if (userEmail) {
-    url += `?email=${encodeURIComponent(userEmail)}`;
-  }
-  return url;
+  return pricingUrl(userEmail ? { email: userEmail } : void 0);
 }
 var init_billing = __esm({
   "src/lib/billing.ts"() {
     "use strict";
-    init_api_client();
+    init_SparkStripe_feature_gating();
   }
 });
 
@@ -340,7 +467,22 @@ var init_config = __esm({
 });
 
 // src/lib/scraping.ts
-var EXCLUDED_LINK_PATTERNS;
+function isExcludedLink(text, href = "") {
+  const lowerText = text.toLowerCase();
+  const lowerHref = href.toLowerCase();
+  return EXCLUDED_LINK_PATTERNS.some((p) => lowerText.includes(p) || lowerHref.includes(p));
+}
+function shouldSkipLink(text, href, currentPath) {
+  if (!href || href === "#") return true;
+  try {
+    const linkPath = new URL(href).pathname;
+    if (linkPath === "/" || linkPath === currentPath) return true;
+  } catch {
+    return true;
+  }
+  return isExcludedLink(text, href);
+}
+var EXCLUDED_LINK_PATTERNS, INTERACTIVE_SELECTORS;
 var init_scraping = __esm({
   "src/lib/scraping.ts"() {
     "use strict";
@@ -407,6 +549,22 @@ var init_scraping = __esm({
       "feed",
       "home"
     ];
+    INTERACTIVE_SELECTORS = [
+      "button",
+      "input",
+      "select",
+      "textarea",
+      "a[href]",
+      '[role="button"]',
+      '[role="checkbox"]',
+      '[role="radio"]',
+      '[role="switch"]',
+      '[role="slider"]',
+      '[role="combobox"]',
+      '[role="menuitem"]',
+      '[type="submit"]',
+      "[onclick]"
+    ];
   }
 });
 
@@ -428,11 +586,17 @@ function getActionForType(type) {
       return "type";
   }
 }
-async function crawlPage(url, task2 = noopTask) {
+async function crawlPage(url, task2 = noopTask, storageStatePath) {
+  const cached = crawlCache.get(url);
+  if (cached && Date.now() - cached.timestamp < CRAWL_CACHE_TTL_MS) {
+    task2("Using cached crawl").succeed(`Found ${cached.elements.length} interactive elements (cached)`);
+    return { title: cached.title, elements: [...cached.elements] };
+  }
   const browserTask = task2("Launching browser");
   const browser = await import_playwright.chromium.launch({ headless: true });
-  const page = await browser.newPage();
-  browserTask.succeed("Browser launched");
+  const context = await browser.newContext(storageStatePath ? { storageState: storageStatePath } : {});
+  const page = await context.newPage();
+  browserTask.succeed(storageStatePath ? "Browser launched (signed in)" : "Browser launched");
   const crawlTask = task2("Crawling page");
   await page.goto(url, { waitUntil: "networkidle", timeout: 3e4 });
   const title = await page.title();
@@ -565,9 +729,14 @@ async function crawlPage(url, task2 = noopTask) {
   });
   await browser.close();
   crawlTask.succeed(`Found ${elements.length} interactive elements`);
+  crawlCache.set(url, { timestamp: Date.now(), title, elements: [...elements] });
+  if (crawlCache.size > CRAWL_CACHE_MAX_ENTRIES) {
+    const oldest = crawlCache.keys().next().value;
+    if (oldest !== void 0) crawlCache.delete(oldest);
+  }
   return { title, elements };
 }
-var import_playwright, noopTask;
+var import_playwright, noopTask, CRAWL_CACHE_TTL_MS, CRAWL_CACHE_MAX_ENTRIES, crawlCache;
 var init_crawl = __esm({
   "src/lib/crawl.ts"() {
     "use strict";
@@ -575,6 +744,9 @@ var init_crawl = __esm({
     init_scraping();
     noopTask = () => ({ succeed: () => {
     } });
+    CRAWL_CACHE_TTL_MS = 5 * 60 * 1e3;
+    CRAWL_CACHE_MAX_ENTRIES = 50;
+    crawlCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -619,10 +791,10 @@ var init_watermark = __esm({
 // src/lib/ffmpeg/spawn.ts
 function toWSLPath(path) {
   if (!isWindowsRuntime) return path;
-  return windowsPathToWSL(path) ?? path.replace(/\\/g, "/");
+  return (0, import_video_kit2.windowsDrivePathToWsl)(path) ?? path.replace(/\\/g, "/");
 }
 function convertArgToWSL(arg2) {
-  const wslPath = windowsPathToWSL(arg2);
+  const wslPath = (0, import_video_kit2.windowsDrivePathToWsl)(arg2);
   if (wslPath) return wslPath;
   if (arg2.includes("\\")) return arg2.replace(/\\/g, "/");
   return arg2;
@@ -719,20 +891,24 @@ function composeVideo(opts) {
         `[1:a]apad=whole_dur=${voiceoverDuration},afade=t=in:st=0:d=${fadeIn}[voice]`,
         // Music: fade in and fade out
         `[2:a]aloop=loop=-1:size=2e+09,atrim=0:${effectiveDuration},volume=${musicVolume},afade=t=in:st=0:d=${musicFadeIn},afade=t=out:st=${musicFadeOutStart}:d=${musicFadeOut}[music]`,
-        `[voice][music]amix=inputs=2:duration=longest[aout]`
+        // Normalise the MIX and hard-limit its true peak - ported from
+        // VidLet, where single-pass loudnorm alone measured +0.9 dBTP on
+        // sharp TTS consonants. -14 LUFS is the YouTube/IG/TikTok playback
+        // target, so the platform leaves the audio untouched.
+        `[voice][music]amix=inputs=2:duration=longest,${import_video_kit3.MASTER_CHAIN}[aout]`
       ].join(";");
       args.push("-vf", vfStr);
       args.push("-filter_complex", complexFilter, "-map", "0:v", "-map", "[aout]");
       args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
       args.push("-c:a", "aac", "-b:a", audioBitrate);
     } else if (hasVoiceover) {
-      const af = `apad=whole_dur=${voiceoverDuration},afade=t=in:st=0:d=${fadeIn}`;
+      const af = `apad=whole_dur=${voiceoverDuration},afade=t=in:st=0:d=${fadeIn},${import_video_kit3.MASTER_CHAIN}`;
       args.push("-vf", vfStr);
       args.push("-map", "0:v", "-map", "1:a", "-af", af);
       args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
       args.push("-c:a", "aac", "-b:a", audioBitrate);
     } else if (hasMusic) {
-      const musicFilter = `aloop=loop=-1:size=2e+09,atrim=0:${effectiveDuration},volume=${musicVolume},afade=t=in:st=0:d=${musicFadeIn},afade=t=out:st=${musicFadeOutStart}:d=${musicFadeOut}`;
+      const musicFilter = `aloop=loop=-1:size=2e+09,atrim=0:${effectiveDuration},volume=${musicVolume},afade=t=in:st=0:d=${musicFadeIn},afade=t=out:st=${musicFadeOutStart}:d=${musicFadeOut},${import_video_kit3.MASTER_CHAIN}`;
       args.push("-vf", vfStr);
       args.push("-map", "0:v", "-map", "1:a", "-af", musicFilter);
       args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
@@ -745,9 +921,11 @@ function composeVideo(opts) {
     runFFmpeg(args, "ffmpeg compose failed").then(resolve9, reject);
   });
 }
+var import_video_kit3;
 var init_compose = __esm({
   "src/lib/ffmpeg/compose.ts"() {
     "use strict";
+    import_video_kit3 = require("@spark-apps/video-kit");
     init_watermark();
     init_spawn();
   }
@@ -1004,14 +1182,13 @@ function applyTransitions(opts) {
       filterParts.push(`[0:v]trim=start=${start.toFixed(3)}:end=${end.toFixed(3)},setpts=PTS-STARTPTS[v${i}]`);
     }
     let currentV = "v0";
+    let chainDuration = boundaries[1] - boundaries[0];
     for (let i = 0; i < sorted.length; i++) {
       const trans = sorted[i];
       const duration = trans.duration ?? 0.3;
       const nextIdx = i + 1;
-      const segStart = boundaries[i];
-      const segEnd = boundaries[i + 1];
-      const segDuration = segEnd - segStart;
-      const offset = Math.max(0, segDuration - duration);
+      const offset = Math.max(0, chainDuration - duration);
+      chainDuration += boundaries[nextIdx + 1] - boundaries[nextIdx] - duration;
       const xfadeType = trans.type === "fade" ? "fadeblack" : "fade";
       const outV = i === sorted.length - 1 ? "outv" : `xv${i}`;
       filterParts.push(
@@ -1212,24 +1389,20 @@ var init_prompts = __esm({
 
 // src/lib/styles.ts
 function generateASSHeader(width, height, font, size, primaryColor, secondaryColor, outlineColor, backColor, bold, outlineWidth, shadow, marginBottom) {
-  return `[Script Info]
-Title: QuickPeek Demo
-ScriptType: v4.00+
-PlayResX: ${width}
-PlayResY: ${height}
-
-[V4+ Styles]
-Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Karaoke,${font},${size},${primaryColor},${secondaryColor},${outlineColor},${backColor},${bold ? 1 : 0},0,0,0,100,100,0,0,1,${outlineWidth},${shadow},2,40,40,${marginBottom},1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-`;
+  return (0, import_video_kit4.buildAssHeader)({
+    title: "QuickPeek Demo",
+    width,
+    height,
+    styles: [
+      `Style: Karaoke,${font},${size},${primaryColor},${secondaryColor},${outlineColor},${backColor},${bold ? 1 : 0},0,0,0,100,100,0,0,1,${outlineWidth},${shadow},2,40,40,${marginBottom},1`
+    ]
+  });
 }
-var CURSOR_MOVE_DURATION, CURSOR_CSS, CURSOR_SCRIPT;
+var import_video_kit4, CURSOR_MOVE_DURATION, CURSOR_CSS, CURSOR_SCRIPT;
 var init_styles = __esm({
   "src/lib/styles.ts"() {
     "use strict";
+    import_video_kit4 = require("@spark-apps/video-kit");
     init_cursor();
     CURSOR_MOVE_DURATION = 800;
     CURSOR_CSS = `
@@ -1273,49 +1446,13 @@ var init_styles = __esm({
 });
 
 // src/lib/subscription-client.ts
-async function fetchStatus(email) {
-  const cacheKey = `${email}:${APP_ID}`;
-  const cached = responseCache.get(cacheKey);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) return cached.data;
-  const stripe = getStripeUrl();
-  try {
-    const params = new URLSearchParams({ email, app_id: APP_ID });
-    const response = await fetch(`${stripe}/api/subscription/status-public?${params}`);
-    if (!response.ok) return null;
-    const data = await response.json();
-    responseCache.set(cacheKey, { data, timestamp: Date.now() });
-    return data;
-  } catch {
-    return null;
-  }
-}
-function resolveTier(status) {
-  return status && PRO_STATUSES.includes(status) ? "pro" : "free";
-}
-async function getTier(userEmail) {
-  const data = await fetchStatus(userEmail);
-  if (!data) return "free";
-  const status = data.subscription?.status;
-  const tier = resolveTier(status);
-  if (tier === "pro" && status === "trialing" && data.subscription?.current_period_end) {
-    if (new Date(data.subscription.current_period_end) <= /* @__PURE__ */ new Date()) return "free";
-  }
-  return tier;
-}
-async function checkVerificationStatus(email) {
-  const data = await fetchStatus(email);
-  if (!data) return { verified: false, tier: "free" };
-  const verified = data.verified === true || data.user?.verified === true || data.user?.email_verified === true;
-  const tier = resolveTier(data.subscription?.status);
-  return { verified, tier };
-}
 async function registerFreeUser(email) {
-  const stripe = getStripeUrl();
+  const APP_ID2 = process.env.SPARK_APP_ID ?? "quickpeek";
   try {
-    const response = await fetch(`${stripe}/api/register-free`, {
+    const response = await fetch(`https://sparkstripe.com/api/register-free`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ email, app_id: APP_ID, app_name: "QuickPeek" })
+      body: JSON.stringify({ email, app_id: APP_ID2, app_name: "QuickPeek" })
     });
     const text = await response.text();
     let data = {};
@@ -1340,21 +1477,15 @@ async function registerFreeUser(email) {
     return { success: false, error: err instanceof Error ? err.message : "Network error" };
   }
 }
-var APP_ID, PRO_STATUSES, CACHE_TTL_MS, responseCache;
 var init_subscription_client = __esm({
   "src/lib/subscription-client.ts"() {
     "use strict";
-    init_api_client();
-    APP_ID = "quickpeek";
-    PRO_STATUSES = ["active", "trialing", "lifetime"];
-    CACHE_TTL_MS = 6e4;
-    responseCache = /* @__PURE__ */ new Map();
   }
 });
 
 // src/lib/tts/helpers.ts
 function toWSLPathForTTS(path) {
-  return windowsPathToWSL(path) ?? path;
+  return (0, import_video_kit2.windowsDrivePathToWsl)(path) ?? path;
 }
 function estimateActionDuration(step) {
   if (step.action === "drag" && step.value === "around") {
@@ -1384,8 +1515,8 @@ async function getMediaStepDuration(step, baseDir) {
   if (!["mp4", "webm", "mov"].includes(ext)) {
     return 0;
   }
-  const mediaPath = (0, import_node_path.isAbsolute)(step.value) ? step.value : (0, import_node_path.resolve)(baseDir, step.value);
-  if (!(0, import_node_fs.existsSync)(mediaPath)) {
+  const mediaPath = (0, import_node_path2.isAbsolute)(step.value) ? step.value : (0, import_node_path2.resolve)(baseDir, step.value);
+  if (!(0, import_node_fs2.existsSync)(mediaPath)) {
     return 0;
   }
   try {
@@ -1405,38 +1536,38 @@ async function getMediaStepDuration(step, baseDir) {
   }
 }
 async function loadVoiceoverMeta(outputDir) {
-  const metaPath = (0, import_node_path.join)(outputDir, "voiceover.json");
+  const metaPath = (0, import_node_path2.join)(outputDir, "voiceover.json");
   try {
-    if (!(0, import_node_fs.existsSync)(metaPath)) return null;
-    const content = await (0, import_promises.readFile)(metaPath, "utf-8");
+    if (!(0, import_node_fs2.existsSync)(metaPath)) return null;
+    const content = await (0, import_promises2.readFile)(metaPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 async function saveVoiceoverMeta(outputDir, meta) {
-  const metaPath = (0, import_node_path.join)(outputDir, "voiceover.json");
-  await (0, import_promises.writeFile)(metaPath, JSON.stringify(meta, null, 2));
+  const metaPath = (0, import_node_path2.join)(outputDir, "voiceover.json");
+  await (0, import_promises2.writeFile)(metaPath, JSON.stringify(meta, null, 2));
 }
 async function concatenateAudio(inputs, output, workDir) {
   const formatPath = (f) => {
-    const resolved = (0, import_node_path.resolve)(f);
-    return isWindows ? windowsPathToWSL(resolved) ?? resolved : resolved;
+    const resolved = (0, import_node_path2.resolve)(f);
+    return isWindows ? (0, import_video_kit2.windowsDrivePathToWsl)(resolved) ?? resolved : resolved;
   };
   const listContent = inputs.map((f) => `file '${formatPath(f)}'`).join("\n");
-  const listPath = (0, import_node_path.join)(workDir, "concat.txt");
-  await (0, import_promises.writeFile)(listPath, listContent);
+  const listPath = (0, import_node_path2.join)(workDir, "concat.txt");
+  await (0, import_promises2.writeFile)(listPath, listContent);
   await concatMedia(listPath, output);
-  await (0, import_promises.unlink)(listPath).catch(() => {
+  await (0, import_promises2.unlink)(listPath).catch(() => {
   });
 }
-var import_node_fs, import_promises, import_node_path, isWindows;
+var import_node_fs2, import_promises2, import_node_path2, isWindows;
 var init_helpers = __esm({
   "src/lib/tts/helpers.ts"() {
     "use strict";
-    import_node_fs = require("fs");
-    import_promises = require("fs/promises");
-    import_node_path = require("path");
+    import_node_fs2 = require("fs");
+    import_promises2 = require("fs/promises");
+    import_node_path2 = require("path");
     init_ffmpeg2();
     init_utils();
     isWindows = process.platform === "win32";
@@ -1472,7 +1603,7 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
   if (!needsRealignment) {
     return stepAudio;
   }
-  const audioDir = (0, import_node_path2.join)(workDir, "audio");
+  const audioDir = (0, import_node_path3.join)(workDir, "audio");
   const segments = [];
   const alignedStepAudio = /* @__PURE__ */ new Map();
   for (let i = 0; i < actualRecordingDurations.length; i++) {
@@ -1481,20 +1612,20 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
     const voiceDuration = voiceData?.duration ?? 0;
     const recordingDuration = actualRecordingDurations[i] ?? 0;
     const targetDuration = Math.max(voiceDuration, recordingDuration);
-    const audioPath = (0, import_node_path2.join)(audioDir, `step-${stepNum}.mp3`);
-    const originalPaddingPath = (0, import_node_path2.join)(audioDir, `step-${stepNum}-padding.mp3`);
-    const silencePath = (0, import_node_path2.join)(audioDir, `step-${stepNum}-silence.mp3`);
-    if ((0, import_node_fs2.existsSync)(audioPath)) {
+    const audioPath = (0, import_node_path3.join)(audioDir, `step-${stepNum}.mp3`);
+    const originalPaddingPath = (0, import_node_path3.join)(audioDir, `step-${stepNum}-padding.mp3`);
+    const silencePath = (0, import_node_path3.join)(audioDir, `step-${stepNum}-silence.mp3`);
+    if ((0, import_node_fs3.existsSync)(audioPath)) {
       segments.push(audioPath);
-      if ((0, import_node_fs2.existsSync)(originalPaddingPath)) {
+      if ((0, import_node_fs3.existsSync)(originalPaddingPath)) {
         segments.push(originalPaddingPath);
       }
       if (recordingDuration > voiceDuration) {
-        const alignPaddingPath = (0, import_node_path2.join)(audioDir, `step-${stepNum}-align-padding.mp3`);
+        const alignPaddingPath = (0, import_node_path3.join)(audioDir, `step-${stepNum}-align-padding.mp3`);
         await generateSilence(alignPaddingPath, recordingDuration - voiceDuration);
         segments.push(alignPaddingPath);
       }
-    } else if ((0, import_node_fs2.existsSync)(silencePath)) {
+    } else if ((0, import_node_fs3.existsSync)(silencePath)) {
       if (targetDuration !== voiceDuration) {
         await generateSilence(silencePath, targetDuration);
       }
@@ -1506,7 +1637,7 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
     });
   }
   if (segments.length > 0) {
-    const voiceoverPath = (0, import_node_path2.join)(outputDir, "voiceover.wav");
+    const voiceoverPath = (0, import_node_path3.join)(outputDir, "voiceover.wav");
     await concatenateAudio(segments, voiceoverPath, workDir);
   }
   const existingMeta = await loadVoiceoverMeta(outputDir);
@@ -1518,12 +1649,12 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
   }
   return alignedStepAudio;
 }
-var import_node_fs2, import_node_path2;
+var import_node_fs3, import_node_path3;
 var init_timing = __esm({
   "src/lib/tts/timing.ts"() {
     "use strict";
-    import_node_fs2 = require("fs");
-    import_node_path2 = require("path");
+    import_node_fs3 = require("fs");
+    import_node_path3 = require("path");
     init_ffmpeg2();
     init_helpers();
   }
@@ -1554,7 +1685,7 @@ function canReuseVoiceover(steps, voice, existingMeta) {
 }
 async function loadExistingVoiceover(steps, outputDir, meta, config) {
   const { estimateWordTimings: estimateWordTimings2 } = await Promise.resolve().then(() => (init_timing(), timing_exports));
-  const voiceoverPath = (0, import_node_path3.join)(outputDir, "voiceover.wav");
+  const voiceoverPath = (0, import_node_path4.join)(outputDir, "voiceover.wav");
   const stepAudio = /* @__PURE__ */ new Map();
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
@@ -1567,97 +1698,29 @@ async function loadExistingVoiceover(steps, outputDir, meta, config) {
   }
   return { voiceoverPath, stepAudio };
 }
-var import_node_path3;
+var import_node_path4;
 var init_cache = __esm({
   "src/lib/tts/cache.ts"() {
     "use strict";
-    import_node_path3 = require("path");
+    import_node_path4 = require("path");
     init_helpers();
   }
 });
 
 // src/lib/voices.ts
-var LANGUAGE_VOICES;
+var import_video_kit5;
 var init_voices = __esm({
   "src/lib/voices.ts"() {
     "use strict";
-    LANGUAGE_VOICES = {
-      en: "en-GB-SoniaNeural",
-      ar: "ar-LB-LaylaNeural",
-      es: "es-ES-ElviraNeural",
-      fr: "fr-FR-DeniseNeural",
-      de: "de-DE-KatjaNeural",
-      it: "it-IT-ElsaNeural",
-      pt: "pt-BR-FranciscaNeural",
-      ru: "ru-RU-SvetlanaNeural",
-      zh: "zh-CN-XiaoxiaoNeural",
-      ja: "ja-JP-NanamiNeural",
-      ko: "ko-KR-SunHiNeural",
-      hi: "hi-IN-SwaraNeural",
-      tr: "tr-TR-EmelNeural",
-      nl: "nl-NL-ColetteNeural",
-      pl: "pl-PL-AgnieszkaNeural",
-      sv: "sv-SE-SofieNeural",
-      he: "he-IL-HilaNeural",
-      th: "th-TH-PremwadeeNeural",
-      vi: "vi-VN-HoaiMyNeural",
-      id: "id-ID-GadisNeural",
-      ms: "ms-MY-YasminNeural",
-      fil: "fil-PH-BlessicaNeural",
-      uk: "uk-UA-PolinaNeural",
-      cs: "cs-CZ-VlastaNeural",
-      el: "el-GR-AthinaNeural",
-      ro: "ro-RO-AlinaNeural",
-      hu: "hu-HU-NoemiNeural",
-      da: "da-DK-ChristelNeural",
-      fi: "fi-FI-NooraNeural",
-      no: "nb-NO-PernilleNeural",
-      sk: "sk-SK-ViktoriaNeural",
-      bg: "bg-BG-KalinaNeural",
-      hr: "hr-HR-GabrijelaNeural",
-      sl: "sl-SI-PetraNeural",
-      et: "et-EE-AnuNeural",
-      lv: "lv-LV-EveritaNeural",
-      lt: "lt-LT-OnaNeural",
-      bn: "bn-IN-TanishaaNeural",
-      ta: "ta-IN-PallaviNeural",
-      te: "te-IN-ShrutiNeural",
-      mr: "mr-IN-AarohiNeural",
-      gu: "gu-IN-DhwaniNeural",
-      kn: "kn-IN-SapnaNeural",
-      ml: "ml-IN-SobhanaNeural",
-      ur: "ur-PK-UzmaNeural",
-      fa: "fa-IR-DilaraNeural",
-      sw: "sw-KE-ZuriNeural",
-      af: "af-ZA-AdriNeural",
-      ca: "ca-ES-JoanaNeural",
-      cy: "cy-GB-NiaNeural",
-      ga: "ga-IE-OrlaNeural",
-      mt: "mt-MT-GraceNeural",
-      is: "is-IS-GudrunNeural",
-      mk: "mk-MK-MarijaNeural",
-      sr: "sr-RS-SophieNeural",
-      bs: "bs-BA-VesnaNeural",
-      sq: "sq-AL-AnilaNeural",
-      am: "am-ET-MekdesNeural",
-      az: "az-AZ-BabekNeural",
-      ka: "ka-GE-EkaNeural",
-      kk: "kk-KZ-AigulNeural",
-      mn: "mn-MN-YesUINeural",
-      ne: "ne-NP-HemkalaNeural",
-      ps: "ps-AF-LatifaNeural",
-      si: "si-LK-ThiliniNeural",
-      so: "so-SO-UbaxNeural",
-      zu: "zu-ZA-ThandoNeural"
-    };
+    import_video_kit5 = require("@spark-apps/video-kit");
   }
 });
 
 // src/lib/tts/synthesize.ts
 async function synthesizeSpeech(text, outputPath, voice) {
-  const tempScriptPath = (0, import_node_path4.join)((0, import_node_path4.resolve)(outputPath, ".."), `tts-${Date.now()}.py`);
-  const wslScriptPath = isWindows ? toWSLPathForTTS((0, import_node_path4.resolve)(tempScriptPath)) : tempScriptPath;
-  const wslOutputPath = isWindows ? toWSLPathForTTS((0, import_node_path4.resolve)(outputPath)) : outputPath;
+  const tempScriptPath = (0, import_node_path5.join)((0, import_node_path5.resolve)(outputPath, ".."), `tts-${Date.now()}.py`);
+  const wslScriptPath = isWindows ? toWSLPathForTTS((0, import_node_path5.resolve)(tempScriptPath)) : tempScriptPath;
+  const wslOutputPath = isWindows ? toWSLPathForTTS((0, import_node_path5.resolve)(outputPath)) : outputPath;
   const pythonScript = `
 import asyncio
 from edge_tts import Communicate
@@ -1672,7 +1735,7 @@ async def main():
 asyncio.run(main())
 `;
   try {
-    await (0, import_promises2.writeFile)(tempScriptPath, pythonScript);
+    await (0, import_promises3.writeFile)(tempScriptPath, pythonScript);
     const pythonCmd = isWindows ? `wsl python3 "${wslScriptPath}"` : `python3 "${wslScriptPath}"`;
     await execAsync(pythonCmd, { timeout: 3e4 });
     await import("fs/promises").then((fs) => fs.unlink(tempScriptPath).catch(() => {
@@ -1700,13 +1763,13 @@ asyncio.run(main())
     }
   }
 }
-var import_node_child_process2, import_promises2, import_node_path4, import_node_util, execAsync;
+var import_node_child_process2, import_promises3, import_node_path5, import_node_util, execAsync;
 var init_synthesize = __esm({
   "src/lib/tts/synthesize.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
-    import_promises2 = require("fs/promises");
-    import_node_path4 = require("path");
+    import_promises3 = require("fs/promises");
+    import_node_path5 = require("path");
     import_node_util = require("util");
     init_helpers();
     execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
@@ -1720,7 +1783,7 @@ function estimateDurationFromText(text, wordsPerMinute = 150) {
 }
 function resolveVoice(config) {
   if (config.audio?.voice) return config.audio.voice;
-  if (config.lang) return LANGUAGE_VOICES[config.lang] || null;
+  if (config.lang) return import_video_kit5.WIDE_VOICES[config.lang] || null;
   return null;
 }
 async function generateVoiceover(steps, config, workDir, outputDir, logError2, task2, info2) {
@@ -1745,8 +1808,8 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
     info2("No voice configured");
     return { voiceoverPath: "", stepAudio: stepAudio2 };
   }
-  const audioDir = (0, import_node_path5.join)(workDir, "audio");
-  await (0, import_promises3.mkdir)(audioDir, { recursive: true });
+  const audioDir = (0, import_node_path6.join)(workDir, "audio");
+  await (0, import_promises4.mkdir)(audioDir, { recursive: true });
   const segments = [];
   const stepAudio = /* @__PURE__ */ new Map();
   const ttsTask = task2("Generating voiceover");
@@ -1758,13 +1821,13 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
       const manualDuration = (step.duration ?? 0) * 1e3;
       const mediaDuration = await getMediaStepDuration(step, outputDir);
       const silenceDuration = Math.max(actionDuration, manualDuration, mediaDuration, config.timing.minStepDuration);
-      const silencePath = (0, import_node_path5.join)(audioDir, `step-${stepNum}-silence.mp3`);
+      const silencePath = (0, import_node_path6.join)(audioDir, `step-${stepNum}-silence.mp3`);
       await generateSilence(silencePath, silenceDuration);
       segments.push(silencePath);
       stepAudio.set(stepNum, { duration: silenceDuration, words: [] });
       continue;
     }
-    const audioPath = (0, import_node_path5.join)(audioDir, `step-${stepNum}.mp3`);
+    const audioPath = (0, import_node_path6.join)(audioDir, `step-${stepNum}.mp3`);
     if (segments.length > 0) await new Promise((r) => setTimeout(r, 200));
     try {
       await synthesizeSpeech(step.caption, audioPath, voice);
@@ -1781,7 +1844,7 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
         mediaDuration
       );
       if (stepDuration > audioDuration) {
-        const paddingPath = (0, import_node_path5.join)(audioDir, `step-${stepNum}-padding.mp3`);
+        const paddingPath = (0, import_node_path6.join)(audioDir, `step-${stepNum}-padding.mp3`);
         await generateSilence(paddingPath, stepDuration - audioDuration);
         segments.push(paddingPath);
       }
@@ -1797,8 +1860,8 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
     return { voiceoverPath: "", stepAudio };
   }
   const concatTask = task2("Combining audio");
-  await (0, import_promises3.mkdir)(outputDir, { recursive: true });
-  const voiceoverPath = (0, import_node_path5.join)(outputDir, "voiceover.wav");
+  await (0, import_promises4.mkdir)(outputDir, { recursive: true });
+  const voiceoverPath = (0, import_node_path6.join)(outputDir, "voiceover.wav");
   await concatenateAudio(segments, voiceoverPath, workDir);
   concatTask.succeed("Done");
   const meta = {
@@ -1811,12 +1874,12 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
   await saveVoiceoverMeta(outputDir, meta);
   return { voiceoverPath, stepAudio };
 }
-var import_promises3, import_node_path5;
+var import_promises4, import_node_path6;
 var init_generate = __esm({
   "src/lib/tts/generate.ts"() {
     "use strict";
-    import_promises3 = require("fs/promises");
-    import_node_path5 = require("path");
+    import_promises4 = require("fs/promises");
+    import_node_path6 = require("path");
     init_ffmpeg2();
     init_voices();
     init_helpers();
@@ -1869,7 +1932,9 @@ __export(lib_exports, {
   DEFAULT_CAPTIONS: () => DEFAULT_CAPTIONS,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
   EXCLUDED_LINK_PATTERNS: () => EXCLUDED_LINK_PATTERNS,
-  LANGUAGE_VOICES: () => LANGUAGE_VOICES,
+  FEATURES: () => FEATURES,
+  INTERACTIVE_SELECTORS: () => INTERACTIVE_SELECTORS,
+  LANGUAGE_VOICES: () => import_video_kit5.WIDE_VOICES,
   VERSION: () => VERSION,
   alignVoiceoverToRecording: () => alignVoiceoverToRecording,
   applyTransitions: () => applyTransitions,
@@ -1879,8 +1944,8 @@ __export(lib_exports, {
   buildUserPrompt: () => buildUserPrompt,
   buildWatermarkFilters: () => buildWatermarkFilters,
   callAI: () => callAI,
+  callAIViaRelay: () => callAIViaRelay,
   canReuseVoiceover: () => canReuseVoiceover,
-  checkVerificationStatus: () => checkVerificationStatus,
   composeVideo: () => composeVideo,
   concatMedia: () => concatMedia,
   concatVideoWithOutro: () => concatVideoWithOutro,
@@ -1889,30 +1954,38 @@ __export(lib_exports, {
   generateASSHeader: () => generateASSHeader,
   generateSilence: () => generateSilence,
   generateVoiceover: () => generateVoiceover,
-  getBackendUrls: () => getBackendUrls,
-  getCredentials: () => getCredentials,
   getErrorMessage: () => getErrorMessage,
-  getGroqApiKey: () => getGroqApiKey,
   getLanguageName: () => getLanguageName,
   getMediaDuration: () => getMediaDuration,
-  getStripeUrl: () => getStripeUrl,
-  getTier: () => getTier,
+  getStatus: () => getStatus,
+  getStatusCached: () => getStatusCached,
+  getTierByEmail: () => getTierByEmail,
   getUpgradeUrl: () => getUpgradeUrl,
-  hasCredentials: () => hasCredentials,
-  hexToASS: () => hexToASS,
+  hasAccess: () => hasAccess,
+  hasTrialRemaining: () => hasTrialRemaining,
+  hexToASS: () => import_video_kit.hexToAss,
+  isCanceling: () => isCanceling,
+  isExcludedLink: () => isExcludedLink,
+  isPaid: () => isPaid,
+  isVerified: () => isVerified,
   loadExistingVoiceover: () => loadExistingVoiceover,
   loadVoiceoverMeta: () => loadVoiceoverMeta,
   mapTimestampsAfterCompression: () => mapTimestampsAfterCompression,
+  normalizeUrl: () => normalizeUrl,
+  parseAIPlanResponse: () => parseAIPlanResponse,
   parsePartial: () => parsePartial,
+  pricingUrl: () => pricingUrl,
   registerFreeUser: () => registerFreeUser,
   resolveVoice: () => resolveVoice,
   rgbaToHex: () => rgbaToHex,
+  shouldSkipLink: () => shouldSkipLink,
   shouldWatermark: () => shouldWatermark,
+  showPaywall: () => showPaywall,
   speedUpVideo: () => speedUpVideo,
   spliceVideos: () => spliceVideos,
   synthesizeSpeech: () => synthesizeSpeech,
   toTitleCase: () => toTitleCase,
-  windowsPathToWSL: () => windowsPathToWSL
+  windowsPathToWSL: () => import_video_kit2.windowsDrivePathToWsl
 });
 var init_lib = __esm({
   "src/lib/index.ts"() {
@@ -1924,6 +1997,7 @@ var init_lib = __esm({
     init_cursor();
     init_ffmpeg2();
     init_prompts();
+    init_SparkStripe_feature_gating();
     init_scraping();
     init_styles();
     init_subscription_client();
@@ -1937,134 +2011,692 @@ var init_lib = __esm({
 
 // src/qp.ts
 var import_dotenv = __toESM(require("dotenv"));
-var import_chalk16 = __toESM(require("chalk"));
+var import_chalk20 = __toESM(require("chalk"));
 
-// src/commands/capture-cmd.ts
-var import_node_path19 = require("path");
-var import_chalk7 = __toESM(require("chalk"));
-
-// src/ai/narrate.ts
-init_lib();
+// src/commands/auth-cmd.ts
+var import_node_readline2 = require("readline");
+var import_chalk3 = __toESM(require("chalk"));
+var import_playwright2 = require("playwright");
 
-// src/ai/client.ts
-var import_node_readline = require("readline");
-var import_chalk = __toESM(require("chalk"));
-init_lib();
-var lastRateLimitInfo = null;
-function getLastRateLimitInfo() {
-  return lastRateLimitInfo;
+// src/browser/auth-state.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var AUTH_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".quickpeek", "auth");
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return null;
+  }
 }
-function prompt(question) {
-  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve9) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve9(answer.trim());
-    });
-  });
+function authStatePath(url) {
+  const host = hostOf(url);
+  return host ? (0, import_node_path.join)(AUTH_DIR, `${host}.json`) : null;
 }
-async function setupUserEmail() {
-  console.log();
-  console.log(import_chalk.default.yellow("  \u2709 Account Setup"));
-  console.log(import_chalk.default.dim("  \u2500".repeat(20)));
-  console.log();
-  console.log(import_chalk.default.white("  QuickPeek uses your email to track usage and"));
-  console.log(import_chalk.default.white("  unlock Pro features when you subscribe."));
-  console.log();
-  const email = await prompt(import_chalk.default.white("  Email: "));
-  if (!email) {
-    console.log();
-    console.log(import_chalk.default.red("  No email provided. Exiting."));
-    process.exit(1);
-  }
-  if (!email.includes("@") || !email.includes(".")) {
-    console.log();
-    console.log(import_chalk.default.yellow("  \u26A0 That doesn't look like a valid email address."));
-    const proceed = await prompt(import_chalk.default.white("  Continue anyway? ") + import_chalk.default.dim("[y/N] "));
-    if (proceed.toLowerCase() !== "y") {
-      process.exit(1);
-    }
-  }
-  console.log();
-  console.log(import_chalk.default.green("  \u2713 Email registered"));
-  console.log();
-  return email;
+function findAuthState(url) {
+  const path = authStatePath(url);
+  return path && (0, import_node_fs.existsSync)(path) ? path : void 0;
 }
-function checkCredentials() {
-  if (!hasCredentials()) {
-    console.log();
-    console.log(import_chalk.default.red("  \u26A0 Spark AI API key not configured"));
-    console.log();
-    console.log(import_chalk.default.dim("  Set the following environment variable:"));
-    console.log(import_chalk.default.white("  SPARK_API_KEY=your-spark-api-key"));
-    console.log();
-    console.log(import_chalk.default.dim("  Get a key at: https://sparkbrain.app/dashboard"));
-    console.log();
-    process.exit(1);
-  }
+async function saveAuthState(url, state) {
+  const path = authStatePath(url);
+  if (!path) throw new Error(`Not a valid URL: ${url}`);
+  await (0, import_promises.mkdir)(AUTH_DIR, { recursive: true });
+  await (0, import_promises.writeFile)(path, JSON.stringify(state, null, 2));
+  await (0, import_promises.chmod)(path, 384);
+  return path;
 }
-async function callGroq(systemPrompt, userPrompt, logError2, _userEmail, tier = "free") {
-  const result = await callAI(systemPrompt, userPrompt, tier);
-  if (!result.success) {
-    await logError2("AI API", new Error(result.error));
-    if (result.isRateLimit) {
-      console.log();
-      console.log(import_chalk.default.red("  \u26A0 Rate Limit Reached (after 3 retries)"));
-      console.log();
-      console.log(import_chalk.default.dim("  Spark AI daily limit exceeded. You may have hit your quota."));
-      console.log(import_chalk.default.dim("  Options:"));
-      if (result.retryAfterSeconds) {
-        const minutes = Math.ceil(result.retryAfterSeconds / 60);
-        console.log(import_chalk.default.dim(`    \u2022 Wait ${minutes} minutes until quota resets`));
-      } else {
-        console.log(import_chalk.default.dim("    \u2022 Wait until tomorrow (limits reset at midnight UTC)"));
-      }
-      console.log(import_chalk.default.dim("    \u2022 Check your usage at: https://sparkbrain.app/dashboard"));
-      console.log(import_chalk.default.dim("    \u2022 Upgrade to a higher tier for more requests"));
-      console.log();
-      process.exit(1);
-    }
-    if (result.isAuthError) {
-      console.log();
-      console.log(import_chalk.default.red("  \u26A0 Authentication Error"));
-      console.log();
-      console.log(import_chalk.default.dim(`  ${result.error}`));
-      console.log();
-      process.exit(1);
-    }
-    console.log();
-    console.log(import_chalk.default.red("  \u26A0 AI Error"));
-    console.log();
-    const firstLine = result.error.split("\n")[0] ?? result.error;
-    console.log(import_chalk.default.dim(`  ${firstLine.slice(0, 80)}`));
-    console.log();
-    process.exit(1);
+async function clearAuthState(url) {
+  if (url) {
+    const path = authStatePath(url);
+    if (!path || !(0, import_node_fs.existsSync)(path)) return [];
+    await (0, import_promises.unlink)(path);
+    return [hostOf(url)];
   }
-  lastRateLimitInfo = result.limits;
-  return result.content;
+  if (!(0, import_node_fs.existsSync)(AUTH_DIR)) return [];
+  const files = (await (0, import_promises.readdir)(AUTH_DIR)).filter((f) => f.endsWith(".json"));
+  await Promise.all(files.map((f) => (0, import_promises.unlink)((0, import_node_path.join)(AUTH_DIR, f))));
+  return files.map((f) => f.slice(0, -".json".length));
+}
+async function listAuthStates() {
+  if (!(0, import_node_fs.existsSync)(AUTH_DIR)) return [];
+  return (await (0, import_promises.readdir)(AUTH_DIR)).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
 
-// src/ai/narrate.ts
-async function generateCaptionsForSteps(steps, url, title, lang, logError2, userEmail, pageContext, tier = "free") {
-  const langName = getLanguageName(lang);
-  const stepList = steps.map((s, i) => {
-    const parts = [`${i + 1}. ${s.action}`];
-    if (s.target) parts.push(`on "${s.target}"`);
-    if (s.value) parts.push(`= "${s.value}"`);
-    return parts.join(" ");
-  }).join("\n");
-  const systemPrompt = `You write professional demo video captions in ${langName}.
-Given UI steps, return a JSON array of captions \u2014 one per step, in order.
-
-RULES:
-- Return ONLY a valid JSON array of strings, no explanation
-- Each caption: 1-2 short conversational sentences, present tense ("We click...", "Here we type...")
-- Describe what the user is doing and why it matters in the context of the app
+// src/help.ts
+var import_chalk = __toESM(require("chalk"));
+init_lib();
 
-OUTPUT: ["Caption for step 1.", "Caption for step 2.", ...]`;
-  const contextLine = pageContext ? `
-App context: ${pageContext}` : "";
-  const userMessage = `App: ${title} (${url})${contextLine}
+// src/logo.ts
+var import_figlet = __toESM(require("figlet"));
+var import_gradient_string = __toESM(require("gradient-string"));
+var DEFAULT_LOGO_CONFIG = {
+  text: "QuickPeek",
+  font: "Slant",
+  horizontalLayout: "default",
+  gradientColors: ["#00ffff", "#00d4ff", "#a855f7", "#ec4899"],
+  suffix: " \u{1F440}"
+};
+function renderLogo(config = {}) {
+  const resolved = { ...DEFAULT_LOGO_CONFIG, ...config };
+  const ascii = import_figlet.default.textSync(resolved.text, {
+    font: resolved.font,
+    horizontalLayout: resolved.horizontalLayout
+  });
+  const colored = (0, import_gradient_string.default)(resolved.gradientColors)(ascii);
+  return resolved.suffix ? `${colored}${resolved.suffix}` : colored;
+}
+
+// src/utils/config-loader.ts
+var import_node_fs4 = require("fs");
+var import_promises5 = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path7 = require("path");
+init_lib();
+async function loadConfig(_url, langOverride) {
+  const configPath = (0, import_node_path7.join)(process.cwd(), CONFIG_FILE);
+  if ((0, import_node_fs4.existsSync)(configPath)) {
+    try {
+      const content = await (0, import_promises5.readFile)(configPath, "utf-8");
+      const userConfig = JSON.parse(content);
+      const config = {
+        lang: langOverride || userConfig.lang || "en",
+        plan: { ...DEFAULT_CONFIG.plan, ...userConfig.plan },
+        video: { ...DEFAULT_CONFIG.video, ...userConfig.video },
+        audio: { ...DEFAULT_CONFIG.audio, ...userConfig.audio },
+        music: userConfig.music,
+        timing: { ...DEFAULT_CONFIG.timing, ...userConfig.timing },
+        output: { ...DEFAULT_CONFIG.output, ...userConfig.output }
+      };
+      return { config, created: false };
+    } catch {
+    }
+  }
+  const fullDefaultConfig = {
+    lang: "en",
+    plan: { maxSteps: 8 },
+    video: {
+      width: 1080,
+      height: 1920,
+      fps: 30,
+      quality: 0.5,
+      preset: "fast",
+      cursor: true,
+      highlight: false,
+      fadeIn: 500,
+      // ms
+      fadeOut: 500,
+      // ms
+      contrast: 0.25
+    },
+    audio: {
+      // Voice is derived from lang setting via LANGUAGE_VOICES mapping
+      // To override, use Edge TTS voice name like 'en-GB-SoniaNeural'
+      speed: 1
+    },
+    music: {
+      path: "",
+      volume: 0.3
+    },
+    output: { dir: "./demo" }
+  };
+  await (0, import_promises5.writeFile)(configPath, JSON.stringify(fullDefaultConfig, null, 2));
+  return { config: { ...DEFAULT_CONFIG, lang: langOverride || "en" }, created: true };
+}
+var WORK_DIR = ".quickpeek";
+async function prepareWorkDir() {
+  const workDir = (0, import_node_path7.join)(process.cwd(), WORK_DIR);
+  if ((0, import_node_fs4.existsSync)(workDir)) {
+    await (0, import_promises5.rm)(workDir, { recursive: true });
+  }
+  await (0, import_promises5.mkdir)(workDir, { recursive: true });
+  return workDir;
+}
+var USER_DATA_DIR = (0, import_node_path7.join)((0, import_node_os2.homedir)(), ".quickpeek");
+var USER_DATA_FILE = (0, import_node_path7.join)(USER_DATA_DIR, "user.json");
+async function loadUserData() {
+  try {
+    if ((0, import_node_fs4.existsSync)(USER_DATA_FILE)) {
+      return JSON.parse(await (0, import_promises5.readFile)(USER_DATA_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+async function saveUserData(userData) {
+  if (!(0, import_node_fs4.existsSync)(USER_DATA_DIR)) {
+    await (0, import_promises5.mkdir)(USER_DATA_DIR, { recursive: true });
+  }
+  const existing = await loadUserData();
+  const merged = { ...existing, ...userData };
+  await (0, import_promises5.writeFile)(USER_DATA_FILE, JSON.stringify(merged, null, 2));
+}
+var DEFAULT_CAPTIONS_CSS = `.caption {
+  font-family: Arial, sans-serif;
+  -webkit-text-stroke: 3px #000000;
+}
+.caption .regular {
+  font-size: 56px;
+  color: #FFFFFF;
+}
+.caption .highlight {
+  font-size: 64px;
+  color: #FFFF00;
+}
+`;
+function parseCaptionCSS(css) {
+  const style = JSON.parse(JSON.stringify(DEFAULT_CAPTIONS));
+  const captionBlock = css.match(/\.caption\s*\{([^}]+)\}/)?.[1] || "";
+  const regularBlock = css.match(/\.caption\s+\.regular\s*\{([^}]+)\}/)?.[1] || "";
+  const highlightBlock = css.match(/\.caption\s+\.highlight\s*\{([^}]+)\}/)?.[1] || "";
+  const fontMatch = captionBlock.match(/font-family:\s*"?([^";,]+)/);
+  if (fontMatch) style.font = fontMatch[1].trim();
+  const strokeMatch = captionBlock.match(/-webkit-text-stroke:\s*(\d+)px\s*(rgba?\([^)]+\)|#[A-Fa-f0-9]{6})/);
+  if (strokeMatch) {
+    style.outlineWidth = parseInt(strokeMatch[1], 10);
+    style.outline = rgbaToHex(strokeMatch[2]);
+  }
+  const shadowMatch = captionBlock.match(/text-shadow:\s*(\d+)px/);
+  if (shadowMatch) style.shadow = parseInt(shadowMatch[1], 10);
+  const marginMatch = captionBlock.match(/margin-bottom:\s*(\d+)/);
+  if (marginMatch) style.marginBottom = parseInt(marginMatch[1], 10);
+  const parseWordStyle = (block, target) => {
+    const colorMatch = block.match(/[^-]color:\s*(#[A-Fa-f0-9]{6})/);
+    if (colorMatch) target.color = colorMatch[1];
+    const sizeMatch = block.match(/font-size:\s*(\d+)/);
+    if (sizeMatch) target.size = parseInt(sizeMatch[1], 10);
+    const weightMatch = block.match(/font-weight:\s*(bold|normal|\d+)/);
+    if (weightMatch) target.bold = weightMatch[1] === "bold" || parseInt(weightMatch[1], 10) >= 700;
+  };
+  parseWordStyle(regularBlock, style.regular);
+  parseWordStyle(highlightBlock, style.highlight);
+  if (!regularBlock && !highlightBlock) {
+    const colorMatch = captionBlock.match(/[^-]color:\s*(#[A-Fa-f0-9]{6})/);
+    if (colorMatch) style.regular.color = colorMatch[1];
+    const sizeMatch = captionBlock.match(/font-size:\s*(\d+)/);
+    if (sizeMatch) {
+      style.regular.size = parseInt(sizeMatch[1], 10);
+      style.highlight.size = Math.round(style.regular.size * 1.15);
+    }
+    const highlightMatch = captionBlock.match(/-qp-highlight:\s*(#[A-Fa-f0-9]{6})/);
+    if (highlightMatch) style.highlight.color = highlightMatch[1];
+    const weightMatch = captionBlock.match(/font-weight:\s*(bold|normal|\d+)/);
+    if (weightMatch) {
+      const isBold = weightMatch[1] === "bold" || parseInt(weightMatch[1], 10) >= 700;
+      style.regular.bold = isBold;
+      style.highlight.bold = isBold;
+    }
+  }
+  return style;
+}
+async function loadCaptions() {
+  const captionsPath = (0, import_node_path7.join)(process.cwd(), "captions.css");
+  if (!(0, import_node_fs4.existsSync)(captionsPath)) {
+    await (0, import_promises5.writeFile)(captionsPath, DEFAULT_CAPTIONS_CSS);
+    return DEFAULT_CAPTIONS;
+  }
+  try {
+    const css = await (0, import_promises5.readFile)(captionsPath, "utf-8");
+    return parseCaptionCSS(css);
+  } catch {
+    return DEFAULT_CAPTIONS;
+  }
+}
+async function savePlan(plan, planPath) {
+  const cleanPlan = {
+    ...plan,
+    steps: plan.steps.map(({ duration, ...step }) => step)
+  };
+  await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(planPath), { recursive: true });
+  await (0, import_promises5.writeFile)(planPath, JSON.stringify(cleanPlan, null, 2));
+}
+
+// src/help.ts
+var cmd = import_chalk.default.cyan;
+var arg = import_chalk.default.green;
+var opt = import_chalk.default.magenta;
+var desc = import_chalk.default.white;
+var ex = import_chalk.default.dim;
+function pad(colored, visible, width) {
+  return colored + " ".repeat(Math.max(0, width - visible.length));
+}
+function showLogo() {
+  const logo = renderLogo();
+  console.log(logo);
+  console.log(import_chalk.default.dim(`  v${VERSION} - Auto-generate demo videos with AI`));
+  console.log(import_chalk.default.italic.dim("  Because Tutorial Videos are Overrated!\n"));
+}
+function formatUsageLines(status, tier) {
+  const lines = [];
+  lines.push(`Videos generated: ${status.usage_count}`);
+  if (tier !== "pro" && status.trial) {
+    const { uses_remaining, max_uses, days_remaining, is_expired } = status.trial;
+    const used = max_uses - uses_remaining;
+    lines.push(`Trial: ${used}/${max_uses} uses${is_expired ? " (expired)" : ` (${uses_remaining} remaining)`}`);
+    if (!is_expired && days_remaining > 0) {
+      lines.push(`Trial ends in ${days_remaining} day${days_remaining === 1 ? "" : "s"}`);
+    }
+  }
+  if (tier === "pro" && status.subscription) {
+    const end = status.subscription.current_period_end;
+    if (status.subscription.is_lifetime) {
+      lines.push("Lifetime access");
+    } else if (isCanceling(status)) {
+      const date = new Date(end).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+      lines.push(`Cancels: ${date}`);
+    } else if (end) {
+      const date = new Date(end).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+      lines.push(`Renews: ${date}`);
+    }
+  }
+  return lines;
+}
+async function showAccount() {
+  const userData = await loadUserData();
+  if (!userData.email) {
+    console.log(import_chalk.default.dim("  Not signed in. Run ") + cmd("qp login") + import_chalk.default.dim(" to sign in."));
+    console.log();
+    return;
+  }
+  const email = userData.email;
+  const tier = userData.tier === "pro" ? "pro" : "free";
+  const tierLabel = tier === "pro" ? import_chalk.default.green("Pro") : "Free";
+  console.log(`  ${tierLabel} plan ${import_chalk.default.dim("\xB7")} ${import_chalk.default.dim(email)}`);
+  try {
+    const status = await getStatusCached(email);
+    for (const line of formatUsageLines(status, tier)) {
+      console.log(import_chalk.default.dim(`  ${line}`));
+    }
+  } catch {
+  }
+  console.log();
+}
+async function showHelp() {
+  showLogo();
+  await showAccount();
+  const W = 28;
+  const usage = [
+    [`${cmd("qp")} ${arg("<url>")}`, `qp <url>`, "AI-generated demo video"],
+    [
+      `${cmd("qp")} ${arg("<url>")} ${opt("--script")} ${arg("<file>")}`,
+      `qp <url> --script <file>`,
+      "Use your own narration script"
+    ],
+    [`${cmd("qp capture")} ${arg("<url>")}`, `qp capture <url>`, "Record interactions manually"],
+    [`${cmd("qp login")}`, `qp login`, "Sign in with your Google account"],
+    [`${cmd("qp logout")}`, `qp logout`, "Sign out"],
+    [`${cmd("qp auth")} ${arg("<url>")}`, `qp auth <url>`, "Save a signed-in session for a site you demo"],
+    [`${cmd("qp auth clear")} ${arg("[url]")}`, `qp auth clear [url]`, "Forget saved sessions"],
+    [`${cmd("qp init")}`, `qp init`, "Create config file"],
+    [`${cmd("qp config")} ${arg("<key>")} ${arg("<value>")}`, `qp config <key> <value>`, "Update a config option"]
+  ];
+  const options = [
+    [`${opt("lang=")}${arg("xx")}`, `lang=xx`, "Voice language (en, es, ar, zh, fr, de, ja...)"],
+    [
+      `${opt("-d")}, ${opt("--description")} ${arg('"..."')}`,
+      `-d, --description "..."`,
+      "Guide AI with an app description"
+    ],
+    [
+      `${opt("-s")}, ${opt("--script")} ${arg("<file>")}`,
+      `-s, --script <file>`,
+      "Narration script (one caption per line)"
+    ],
+    [`${opt("-y")}, ${opt("--yes")}`, `-y, --yes`, "Skip confirmation prompts"],
+    [`${opt("--skip-voice")}, ${opt("-sv")}`, `--skip-voice, -sv`, "Reuse existing voiceover"],
+    [`${opt("-f")}, ${opt("--fresh")}`, `-f, --fresh`, "Clear cached voiceover and recording"]
+  ];
+  const examples = [
+    `${ex("$")} ${cmd("qp")} ${arg("localhost:3000")}`,
+    `${ex("$")} ${cmd("qp")} ${arg("myapp.com")} ${opt("lang=")}${arg("es")} ${opt("-d")} ${arg('"E-commerce checkout flow"')}`,
+    `${ex("$")} ${cmd("qp")} ${arg("myapp.com")} ${opt("--script")} ${arg("narration.txt")}`,
+    `${ex("$")} ${cmd("qp capture")} ${arg("localhost:3000")}`
+  ];
+  console.log();
+  console.log(import_chalk.default.yellow.bold("USAGE"));
+  for (const [colored, plain, d] of usage) {
+    console.log(`  ${pad(colored, plain, W)}${desc(d)}`);
+  }
+  console.log();
+  console.log(import_chalk.default.yellow.bold("OPTIONS"));
+  for (const [colored, plain, d] of options) {
+    console.log(`  ${pad(colored, plain, W)}${desc(d)}`);
+  }
+  console.log();
+  console.log(import_chalk.default.yellow.bold("EXAMPLES"));
+  for (const e of examples) {
+    console.log(`  ${e}`);
+  }
+  console.log();
+}
+
+// src/utils/ui.ts
+var import_node_path8 = require("path");
+var import_node_readline = require("readline");
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var INDENT = "   ";
+var autoYes = false;
+function setAutoYes(value) {
+  autoYes = value;
+}
+function task(text) {
+  return (0, import_ora.default)({ text, prefixText: INDENT, spinner: "dots" }).start();
+}
+function header(text) {
+  console.log();
+  console.log(import_chalk2.default.bold.cyan(`\u25A0 ${text}`));
+}
+function info(text) {
+  console.log(`${INDENT}${import_chalk2.default.dim("\u2502")} ${import_chalk2.default.dim(text)}`);
+}
+function confirm(prompt2) {
+  if (autoYes) return Promise.resolve(true);
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => {
+    rl.question(import_chalk2.default.yellow(`${prompt2} [Y/n] `), (answer) => {
+      rl.close();
+      res(answer.toLowerCase() !== "n");
+    });
+  });
+}
+function promptInput(prompt2) {
+  if (autoYes) return Promise.resolve("");
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => {
+    rl.question(import_chalk2.default.cyan(`${INDENT}${prompt2}`), (answer) => {
+      rl.close();
+      res(answer.trim());
+    });
+  });
+}
+var _isWSL = process.platform === "linux" && process.env.WSL_DISTRO_NAME;
+function formatClickablePath(filePath) {
+  const absolutePath = (0, import_node_path8.resolve)(filePath);
+  if (_isWSL) {
+    return absolutePath;
+  }
+  let formatted = absolutePath;
+  formatted = formatted.replace(/\//g, "\\");
+  if (formatted.includes(" ") && !formatted.startsWith('"')) {
+    formatted = `"${formatted}"`;
+  }
+  return formatted;
+}
+function formatDuration(ms) {
+  const mins = Math.floor(ms / 6e4);
+  const secs = Math.floor(ms % 6e4 / 1e3);
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+
+// src/commands/auth-cmd.ts
+function waitForEnter(prompt2) {
+  return new Promise((resolve9) => {
+    const rl = (0, import_node_readline2.createInterface)({ input: process.stdin, output: process.stdout });
+    rl.question(prompt2, () => {
+      rl.close();
+      resolve9();
+    });
+  });
+}
+async function authCommand(url) {
+  console.log();
+  showLogo();
+  if (!authStatePath(url)) {
+    console.log(import_chalk3.default.red(`  Not a valid URL: ${url}`));
+    return;
+  }
+  console.log(import_chalk3.default.white("  A browser will open. Sign in to the site, then come back here."));
+  console.log();
+  const browser = await import_playwright2.chromium.launch({ headless: false });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+  } catch {
+  }
+  await waitForEnter(import_chalk3.default.cyan("  Press Enter when you are signed in... "));
+  try {
+    const state = await context.storageState();
+    const path = await saveAuthState(url, state);
+    console.log();
+    console.log(import_chalk3.default.green(`  \u2713 Session saved for ${new URL(url).host}`));
+    console.log(import_chalk3.default.dim(`  ${formatClickablePath(path)}`));
+    console.log(import_chalk3.default.dim("  Crawls and recordings of this site now start signed in."));
+    console.log(import_chalk3.default.dim("  Run ") + import_chalk3.default.cyan(`qp auth clear ${new URL(url).host}`) + import_chalk3.default.dim(" to forget it."));
+  } finally {
+    await browser.close().catch(() => {
+    });
+  }
+  console.log();
+}
+async function authClearCommand(url) {
+  console.log();
+  const removed = await clearAuthState(url);
+  if (removed.length === 0) {
+    console.log(import_chalk3.default.dim(url ? `  No saved session for ${url}` : "  No saved sessions."));
+  } else {
+    for (const host of removed) {
+      console.log(import_chalk3.default.green(`  \u2713 Forgot session for ${host}`));
+    }
+  }
+  console.log();
+}
+async function authListCommand() {
+  console.log();
+  const hosts = await listAuthStates();
+  if (hosts.length === 0) {
+    console.log(import_chalk3.default.dim("  No saved sessions. Run ") + import_chalk3.default.cyan("qp auth <url>") + import_chalk3.default.dim(" to add one."));
+  } else {
+    console.log(import_chalk3.default.white("  Saved sessions:"));
+    for (const host of hosts) {
+      console.log(`  ${import_chalk3.default.green("\u25CF")} ${host}`);
+    }
+  }
+  console.log();
+}
+
+// src/commands/capture-cmd.ts
+var import_node_path20 = require("path");
+var import_chalk11 = __toESM(require("chalk"));
+
+// src/ai/narrate.ts
+init_lib();
+
+// src/ai/client.ts
+var import_node_readline3 = require("readline");
+var import_chalk5 = __toESM(require("chalk"));
+init_lib();
+
+// src/utils/browser-auth.ts
+var import_node_http = require("http");
+var import_node_url = require("url");
+var import_chalk4 = __toESM(require("chalk"));
+init_SparkStripe_feature_gating();
+var TIMEOUT_MS = 12e4;
+async function openBrowser(url) {
+  const { exec: exec2 } = await import("child_process");
+  const isWSL2 = process.platform === "linux" && Boolean(process.env.WSL_DISTRO_NAME);
+  const command = isWSL2 ? `cmd.exe /c start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  return new Promise((resolve9) => {
+    exec2(command, () => resolve9());
+  });
+}
+async function browserLogin() {
+  return new Promise((resolve9) => {
+    let server;
+    let timer;
+    const cleanup = (email) => {
+      clearTimeout(timer);
+      server?.close();
+      resolve9(email);
+    };
+    server = (0, import_node_http.createServer)((req, res) => {
+      const url = new import_node_url.URL(req.url || "/", `http://localhost`);
+      const path = url.pathname;
+      if (path === "/callback" || path === "/") {
+        const email = url.searchParams.get("email");
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+          <head><title>QuickPeek</title><style>
+            body { font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fff; }
+            .card { text-align: center; padding: 2rem; }
+            h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+            p { color: #888; }
+          </style></head>
+          <body><div class="card">
+            <h1>${email ? "Logged in!" : "Return to your terminal"}</h1>
+            <p>${email ? `Signed in as ${email}` : "Complete setup in your terminal."}</p>
+            <p style="margin-top: 1rem; font-size: 0.875rem;">You can close this tab.</p>
+          </div></body>
+          </html>
+        `);
+        if (email) {
+          cleanup(email);
+        }
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        cleanup(null);
+        return;
+      }
+      const port = addr.port;
+      const returnUrl = `http://localhost:${port}/callback`;
+      const url = pricingUrl({ returnUrl });
+      console.log();
+      console.log(import_chalk4.default.cyan("  Opening browser to sign in..."));
+      console.log(import_chalk4.default.dim(`  ${url}`));
+      console.log();
+      console.log(import_chalk4.default.dim("  Waiting for sign-in (press Ctrl+C to cancel)..."));
+      openBrowser(url);
+    });
+    timer = setTimeout(() => {
+      console.log();
+      console.log(import_chalk4.default.yellow("  Sign-in timed out."));
+      cleanup(null);
+    }, TIMEOUT_MS);
+  });
+}
+
+// src/ai/client.ts
+var lastRateLimitInfo = null;
+function getLastRateLimitInfo() {
+  return lastRateLimitInfo;
+}
+function prompt(question) {
+  const rl = (0, import_node_readline3.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve9) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve9(answer.trim());
+    });
+  });
+}
+async function setupUserEmail() {
+  console.log();
+  console.log(import_chalk5.default.yellow("  \u2709 Account Setup"));
+  console.log(import_chalk5.default.dim("  \u2500".repeat(20)));
+  console.log();
+  console.log(import_chalk5.default.white("  Sign in with your Google account to track usage"));
+  console.log(import_chalk5.default.white("  and unlock Pro features."));
+  const browserEmail = await browserLogin();
+  if (browserEmail) {
+    console.log();
+    console.log(import_chalk5.default.green(`  \u2713 Signed in as ${browserEmail}`));
+    console.log();
+    return browserEmail;
+  }
+  console.log();
+  console.log(import_chalk5.default.dim("  Or enter your email manually:"));
+  const email = await prompt(import_chalk5.default.white("  Email: "));
+  if (!email) {
+    console.log();
+    console.log(import_chalk5.default.red("  No email provided. Exiting."));
+    process.exit(1);
+  }
+  if (!email.includes("@") || !email.includes(".")) {
+    console.log();
+    console.log(import_chalk5.default.yellow("  \u26A0 That doesn't look like a valid email address."));
+    const proceed = await prompt(import_chalk5.default.white("  Continue anyway? ") + import_chalk5.default.dim("[y/N] "));
+    if (proceed.toLowerCase() !== "y") {
+      process.exit(1);
+    }
+  }
+  console.log();
+  console.log(import_chalk5.default.green("  \u2713 Email registered"));
+  console.log();
+  return email;
+}
+async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "free") {
+  const result = process.env.SPARK_AI_KEY ? await callAI(systemPrompt, userPrompt, tier) : await callAIViaRelay(systemPrompt, userPrompt, userEmail ?? "", tier);
+  if (!result.success) {
+    await logError2("AI API", new Error(result.error));
+    if (result.isRateLimit) {
+      console.log();
+      console.log(import_chalk5.default.red("  \u26A0 Rate Limit Reached (after 3 retries)"));
+      console.log();
+      console.log(import_chalk5.default.dim("  Spark AI daily limit exceeded. You may have hit your quota."));
+      console.log(import_chalk5.default.dim("  Options:"));
+      if (result.retryAfterSeconds) {
+        const minutes = Math.ceil(result.retryAfterSeconds / 60);
+        console.log(import_chalk5.default.dim(`    \u2022 Wait ${minutes} minutes until quota resets`));
+      } else {
+        console.log(import_chalk5.default.dim("    \u2022 Wait until tomorrow (limits reset at midnight UTC)"));
+      }
+      console.log(import_chalk5.default.dim("    \u2022 Check your usage at: https://sparkbrain.app/dashboard"));
+      console.log(import_chalk5.default.dim("    \u2022 Upgrade to a higher tier for more requests"));
+      console.log();
+      process.exit(1);
+    }
+    if (result.isAuthError) {
+      console.log();
+      console.log(import_chalk5.default.red("  \u26A0 Authentication Error"));
+      console.log();
+      console.log(import_chalk5.default.dim(`  ${result.error}`));
+      console.log();
+      process.exit(1);
+    }
+    console.log();
+    console.log(import_chalk5.default.red("  \u26A0 AI Error"));
+    console.log();
+    const firstLine = result.error.split("\n")[0] ?? result.error;
+    console.log(import_chalk5.default.dim(`  ${firstLine.slice(0, 80)}`));
+    console.log();
+    process.exit(1);
+  }
+  lastRateLimitInfo = result.limits;
+  return result.content;
+}
+
+// src/ai/narrate.ts
+async function generateCaptionsForSteps(steps, url, title, lang, logError2, userEmail, pageContext, tier = "free") {
+  const langName = getLanguageName(lang);
+  const stepList = steps.map((s, i) => {
+    const parts = [`${i + 1}. ${s.action}`];
+    if (s.target) parts.push(`on "${s.target}"`);
+    if (s.value) parts.push(`= "${s.value}"`);
+    return parts.join(" ");
+  }).join("\n");
+  const systemPrompt = `You write professional demo video captions in ${langName}.
+Given UI steps, return a JSON array of captions \u2014 one per step, in order.
+
+RULES:
+- Return ONLY a valid JSON array of strings, no explanation
+- Each caption: 1-2 short conversational sentences, present tense ("We click...", "Here we type...")
+- Describe what the user is doing and why it matters in the context of the app
+
+OUTPUT: ["Caption for step 1.", "Caption for step 2.", ...]`;
+  const contextLine = pageContext ? `
+App context: ${pageContext}` : "";
+  const userMessage = `App: ${title} (${url})${contextLine}
 
 Steps to caption:
 ${stepList}
@@ -2162,11 +2794,11 @@ function eventsToSteps(events, url) {
   let prevClickSelector;
   let prevClickTime = 0;
   let lastNavigatedUrl;
-  const normalizedOriginUrl = normalizeUrl(url);
+  const normalizedOriginUrl = normalizeUrl2(url);
   for (const event of events) {
     if (event.type === "navigate") {
       if (!event.url) continue;
-      const normalized = normalizeUrl(event.url);
+      const normalized = normalizeUrl2(event.url);
       if (normalized === normalizedOriginUrl) continue;
       if (lastNavigatedUrl !== void 0 && normalized === lastNavigatedUrl) continue;
       lastNavigatedUrl = normalized;
@@ -2216,7 +2848,7 @@ function eventsToSteps(events, url) {
   }
   return steps;
 }
-function normalizeUrl(url) {
+function normalizeUrl2(url) {
   try {
     const u = new URL(url);
     return u.origin + u.pathname.replace(/\/$/, "");
@@ -2227,15 +2859,15 @@ function normalizeUrl(url) {
 
 // src/capture.ts
 var import_node_child_process4 = require("child_process");
-var import_node_http2 = require("http");
-var import_node_readline2 = require("readline");
-var import_playwright3 = require("playwright");
+var import_node_http3 = require("http");
+var import_node_readline4 = require("readline");
+var import_playwright4 = require("playwright");
 
 // src/browser/wsl.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs3 = require("fs");
-var import_node_http = require("http");
-var import_playwright2 = require("playwright");
+var import_node_fs5 = require("fs");
+var import_node_http2 = require("http");
+var import_playwright3 = require("playwright");
 function isWSL() {
   if (process.platform !== "linux") return false;
   try {
@@ -2246,7 +2878,7 @@ function isWSL() {
   }
 }
 function tryEnableWSLInterop() {
-  return (0, import_node_fs3.existsSync)("/proc/sys/fs/binfmt_misc/WSLInterop");
+  return (0, import_node_fs5.existsSync)("/proc/sys/fs/binfmt_misc/WSLInterop");
 }
 function wslToWindowsPath(wslPath) {
   if (!wslPath) return wslPath;
@@ -2255,7 +2887,7 @@ function wslToWindowsPath(wslPath) {
   return `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, "\\")}`;
 }
 function findExe(whereExeQuery, ...hardcoded) {
-  for (const p of hardcoded) if ((0, import_node_fs3.existsSync)(p)) return p;
+  for (const p of hardcoded) if ((0, import_node_fs5.existsSync)(p)) return p;
   try {
     const line = (0, import_node_child_process3.execSync)(`where.exe ${whereExeQuery}`, { encoding: "utf-8", timeout: 3e3 }).split("\n")[0]?.trim();
     if (line) return line.replace(/^([A-Za-z]):\\/, (_, d) => `/mnt/${d.toLowerCase()}/`).replace(/\\/g, "/");
@@ -2278,7 +2910,7 @@ function getWindowsHostIP() {
   } catch {
   }
   try {
-    const m = (0, import_node_fs3.readFileSync)("/etc/resolv.conf", "utf-8").match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
+    const m = (0, import_node_fs5.readFileSync)("/etc/resolv.conf", "utf-8").match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
     if (m?.[1]) return m[1];
   } catch {
   }
@@ -2312,7 +2944,7 @@ function waitForChrome(host, port) {
         reject(new Error("Chrome debug port did not open within 20 s"));
         return;
       }
-      const req = (0, import_node_http.request)({ host, port, path: "/json/version", method: "GET" }, (res) => {
+      const req = (0, import_node_http2.request)({ host, port, path: "/json/version", method: "GET" }, (res) => {
         res.resume();
         resolve9();
       });
@@ -2354,7 +2986,7 @@ async function launchWindowsChrome(extensionPath, userDataDir, options = {}) {
   const { proc: relay, port: proxyPort } = await startRelay(nodePath, windowsHost, debugPort);
   try {
     await waitForChrome(windowsHost, proxyPort);
-    const browser = await import_playwright2.chromium.connectOverCDP(`http://${windowsHost}:${proxyPort}`, { timeout: 5e3 });
+    const browser = await import_playwright3.chromium.connectOverCDP(`http://${windowsHost}:${proxyPort}`, { timeout: 5e3 });
     return {
       browser,
       cleanup: async () => {
@@ -2483,9 +3115,9 @@ var EVENT_TRACKER_SCRIPT = `
   }, { passive: true, capture: true });
 }());
 `;
-function waitForEnter() {
+function waitForEnter2() {
   return new Promise((resolve9) => {
-    const rl = (0, import_node_readline2.createInterface)({ input: process.stdin, output: process.stdout });
+    const rl = (0, import_node_readline4.createInterface)({ input: process.stdin, output: process.stdout });
     process.stdout.write("  Press Enter when done...\n");
     rl.once("line", () => {
       rl.close();
@@ -2502,7 +3134,7 @@ async function launchCaptureChrome() {
   const windowsHost = getWindowsHostIP();
   const probe = await startRelay(nodePath, windowsHost, debugPort);
   const alreadyUp = await new Promise((resolve9) => {
-    const req = (0, import_node_http2.request)({ host: windowsHost, port: probe.port, path: "/json/version", method: "GET" }, (res) => {
+    const req = (0, import_node_http3.request)({ host: windowsHost, port: probe.port, path: "/json/version", method: "GET" }, (res) => {
       res.resume();
       resolve9(true);
     });
@@ -2514,7 +3146,7 @@ async function launchCaptureChrome() {
     req.end();
   });
   if (alreadyUp) {
-    const browser = await import_playwright3.chromium.connectOverCDP(`http://${windowsHost}:${probe.port}`, { timeout: 5e3 });
+    const browser = await import_playwright4.chromium.connectOverCDP(`http://${windowsHost}:${probe.port}`, { timeout: 5e3 });
     return { browser, relay: probe.proc };
   }
   probe.proc.kill();
@@ -2534,7 +3166,7 @@ async function launchCaptureChrome() {
   const relay = await startRelay(nodePath, windowsHost, debugPort);
   try {
     await waitForChrome(windowsHost, relay.port);
-    const browser = await import_playwright3.chromium.connectOverCDP(`http://${windowsHost}:${relay.port}`, { timeout: 5e3 });
+    const browser = await import_playwright4.chromium.connectOverCDP(`http://${windowsHost}:${relay.port}`, { timeout: 5e3 });
     return { browser, relay: relay.proc };
   } catch (err) {
     relay.proc.kill();
@@ -2549,7 +3181,7 @@ async function captureUserSession(url, _workDir) {
   if (isWSL()) {
     ({ browser, relay } = await launchCaptureChrome());
   } else {
-    browser = await import_playwright3.chromium.launch({
+    browser = await import_playwright4.chromium.launch({
       headless: false,
       args: ["--start-maximized", "--no-first-run"]
     });
@@ -2591,7 +3223,7 @@ async function captureUserSession(url, _workDir) {
     return [title, parts.join(" | ")];
   }).catch(() => ["", ""]);
   startTime = Date.now();
-  await waitForEnter();
+  await waitForEnter2();
   const durationMs = Date.now() - startTime;
   if (relay) {
     try {
@@ -2606,195 +3238,31 @@ async function captureUserSession(url, _workDir) {
   return { events, durationMs, pageTitle, pageContext };
 }
 
-// src/utils/config-loader.ts
-var import_node_fs4 = require("fs");
-var import_promises4 = require("fs/promises");
-var import_node_os = require("os");
-var import_node_path6 = require("path");
-init_lib();
-async function loadConfig(_url, langOverride) {
-  const configPath = (0, import_node_path6.join)(process.cwd(), CONFIG_FILE);
-  if ((0, import_node_fs4.existsSync)(configPath)) {
-    try {
-      const content = await (0, import_promises4.readFile)(configPath, "utf-8");
-      const userConfig = JSON.parse(content);
-      const config = {
-        lang: langOverride || userConfig.lang || "en",
-        plan: { ...DEFAULT_CONFIG.plan, ...userConfig.plan },
-        video: { ...DEFAULT_CONFIG.video, ...userConfig.video },
-        audio: { ...DEFAULT_CONFIG.audio, ...userConfig.audio },
-        music: userConfig.music,
-        timing: { ...DEFAULT_CONFIG.timing, ...userConfig.timing },
-        output: { ...DEFAULT_CONFIG.output, ...userConfig.output }
-      };
-      return { config, created: false };
-    } catch {
-    }
-  }
-  const fullDefaultConfig = {
-    lang: "en",
-    plan: { maxSteps: 8 },
-    video: {
-      width: 1080,
-      height: 1920,
-      fps: 30,
-      quality: 0.5,
-      preset: "fast",
-      cursor: true,
-      highlight: false,
-      fadeIn: 500,
-      // ms
-      fadeOut: 500,
-      // ms
-      contrast: 0.25
-    },
-    audio: {
-      // Voice is derived from lang setting via LANGUAGE_VOICES mapping
-      // To override, use Edge TTS voice name like 'en-GB-SoniaNeural'
-      speed: 1
-    },
-    music: {
-      path: "",
-      volume: 0.3
-    },
-    output: { dir: "./demo" }
-  };
-  await (0, import_promises4.writeFile)(configPath, JSON.stringify(fullDefaultConfig, null, 2));
-  return { config: { ...DEFAULT_CONFIG, lang: langOverride || "en" }, created: true };
-}
-var WORK_DIR = ".quickpeek";
-async function prepareWorkDir() {
-  const workDir = (0, import_node_path6.join)(process.cwd(), WORK_DIR);
-  if ((0, import_node_fs4.existsSync)(workDir)) {
-    await (0, import_promises4.rm)(workDir, { recursive: true });
-  }
-  await (0, import_promises4.mkdir)(workDir, { recursive: true });
-  return workDir;
-}
-var USER_DATA_DIR = (0, import_node_path6.join)((0, import_node_os.homedir)(), ".quickpeek");
-var USER_DATA_FILE = (0, import_node_path6.join)(USER_DATA_DIR, "user.json");
-async function loadUserData() {
-  try {
-    if ((0, import_node_fs4.existsSync)(USER_DATA_FILE)) {
-      return JSON.parse(await (0, import_promises4.readFile)(USER_DATA_FILE, "utf-8"));
-    }
-  } catch {
-  }
-  return {};
-}
-async function saveUserData(userData) {
-  if (!(0, import_node_fs4.existsSync)(USER_DATA_DIR)) {
-    await (0, import_promises4.mkdir)(USER_DATA_DIR, { recursive: true });
-  }
-  const existing = await loadUserData();
-  const merged = { ...existing, ...userData };
-  await (0, import_promises4.writeFile)(USER_DATA_FILE, JSON.stringify(merged, null, 2));
-}
-var DEFAULT_CAPTIONS_CSS = `.caption {
-  font-family: Arial, sans-serif;
-  -webkit-text-stroke: 3px #000000;
-}
-.caption .regular {
-  font-size: 56px;
-  color: #FFFFFF;
-}
-.caption .highlight {
-  font-size: 64px;
-  color: #FFFF00;
-}
-`;
-function parseCaptionCSS(css) {
-  const style = JSON.parse(JSON.stringify(DEFAULT_CAPTIONS));
-  const captionBlock = css.match(/\.caption\s*\{([^}]+)\}/)?.[1] || "";
-  const regularBlock = css.match(/\.caption\s+\.regular\s*\{([^}]+)\}/)?.[1] || "";
-  const highlightBlock = css.match(/\.caption\s+\.highlight\s*\{([^}]+)\}/)?.[1] || "";
-  const fontMatch = captionBlock.match(/font-family:\s*"?([^";,]+)/);
-  if (fontMatch) style.font = fontMatch[1].trim();
-  const strokeMatch = captionBlock.match(/-webkit-text-stroke:\s*(\d+)px\s*(rgba?\([^)]+\)|#[A-Fa-f0-9]{6})/);
-  if (strokeMatch) {
-    style.outlineWidth = parseInt(strokeMatch[1], 10);
-    style.outline = rgbaToHex(strokeMatch[2]);
-  }
-  const shadowMatch = captionBlock.match(/text-shadow:\s*(\d+)px/);
-  if (shadowMatch) style.shadow = parseInt(shadowMatch[1], 10);
-  const marginMatch = captionBlock.match(/margin-bottom:\s*(\d+)/);
-  if (marginMatch) style.marginBottom = parseInt(marginMatch[1], 10);
-  const parseWordStyle = (block, target) => {
-    const colorMatch = block.match(/[^-]color:\s*(#[A-Fa-f0-9]{6})/);
-    if (colorMatch) target.color = colorMatch[1];
-    const sizeMatch = block.match(/font-size:\s*(\d+)/);
-    if (sizeMatch) target.size = parseInt(sizeMatch[1], 10);
-    const weightMatch = block.match(/font-weight:\s*(bold|normal|\d+)/);
-    if (weightMatch) target.bold = weightMatch[1] === "bold" || parseInt(weightMatch[1], 10) >= 700;
-  };
-  parseWordStyle(regularBlock, style.regular);
-  parseWordStyle(highlightBlock, style.highlight);
-  if (!regularBlock && !highlightBlock) {
-    const colorMatch = captionBlock.match(/[^-]color:\s*(#[A-Fa-f0-9]{6})/);
-    if (colorMatch) style.regular.color = colorMatch[1];
-    const sizeMatch = captionBlock.match(/font-size:\s*(\d+)/);
-    if (sizeMatch) {
-      style.regular.size = parseInt(sizeMatch[1], 10);
-      style.highlight.size = Math.round(style.regular.size * 1.15);
-    }
-    const highlightMatch = captionBlock.match(/-qp-highlight:\s*(#[A-Fa-f0-9]{6})/);
-    if (highlightMatch) style.highlight.color = highlightMatch[1];
-    const weightMatch = captionBlock.match(/font-weight:\s*(bold|normal|\d+)/);
-    if (weightMatch) {
-      const isBold = weightMatch[1] === "bold" || parseInt(weightMatch[1], 10) >= 700;
-      style.regular.bold = isBold;
-      style.highlight.bold = isBold;
-    }
-  }
-  return style;
-}
-async function loadCaptions() {
-  const captionsPath = (0, import_node_path6.join)(process.cwd(), "captions.css");
-  if (!(0, import_node_fs4.existsSync)(captionsPath)) {
-    await (0, import_promises4.writeFile)(captionsPath, DEFAULT_CAPTIONS_CSS);
-    return DEFAULT_CAPTIONS;
-  }
-  try {
-    const css = await (0, import_promises4.readFile)(captionsPath, "utf-8");
-    return parseCaptionCSS(css);
-  } catch {
-    return DEFAULT_CAPTIONS;
-  }
-}
-async function savePlan(plan, planPath) {
-  const cleanPlan = {
-    ...plan,
-    steps: plan.steps.map(({ duration, ...step }) => step)
-  };
-  await (0, import_promises4.mkdir)((0, import_node_path6.dirname)(planPath), { recursive: true });
-  await (0, import_promises4.writeFile)(planPath, JSON.stringify(cleanPlan, null, 2));
-}
-
 // src/utils/logging.ts
-var import_promises5 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_promises6 = require("fs/promises");
+var import_node_path9 = require("path");
 var LOG_FILE_NAME = "quickpeek.log";
 var logFileInitialized = false;
 var logFilePath = LOG_FILE_NAME;
 async function writeLogEntry(entry) {
   try {
     if (!logFileInitialized) {
-      await (0, import_promises5.writeFile)(logFilePath, entry);
+      await (0, import_promises6.writeFile)(logFilePath, entry);
       logFileInitialized = true;
     } else {
-      await (0, import_promises5.appendFile)(logFilePath, entry);
+      await (0, import_promises6.appendFile)(logFilePath, entry);
     }
   } catch {
   }
 }
 async function setLogFilePath(outputDir) {
-  logFilePath = (0, import_node_path7.join)(outputDir, LOG_FILE_NAME);
+  logFilePath = (0, import_node_path9.join)(outputDir, LOG_FILE_NAME);
   const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
 ${"=".repeat(60)}
 
 `;
   try {
-    await (0, import_promises5.writeFile)(logFilePath, header2);
+    await (0, import_promises6.writeFile)(logFilePath, header2);
     logFileInitialized = true;
   } catch {
   }
@@ -2822,101 +3290,42 @@ ${errorMsg}
 
 `);
 }
-async function logStep(stepNum, action, details) {
-  const detailsStr = Object.entries(details).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [STEP ${stepNum}] ${action} | ${detailsStr}
-`);
-}
-
-// src/utils/ui.ts
-var import_node_path8 = require("path");
-var import_node_readline3 = require("readline");
-var import_chalk2 = __toESM(require("chalk"));
-var import_ora = __toESM(require("ora"));
-var INDENT = "   ";
-var autoYes = false;
-function setAutoYes(value) {
-  autoYes = value;
-}
-function task(text) {
-  return (0, import_ora.default)({ text, prefixText: INDENT, spinner: "dots" }).start();
-}
-function header(text) {
-  console.log();
-  console.log(import_chalk2.default.bold.cyan(`\u25A0 ${text}`));
-}
-function info(text) {
-  console.log(`${INDENT}${import_chalk2.default.dim("\u2502")} ${import_chalk2.default.dim(text)}`);
-}
-function confirm(prompt2) {
-  if (autoYes) return Promise.resolve(true);
-  const rl = (0, import_node_readline3.createInterface)({ input: process.stdin, output: process.stdout });
-  return new Promise((res) => {
-    rl.question(import_chalk2.default.yellow(`${prompt2} [Y/n] `), (answer) => {
-      rl.close();
-      res(answer.toLowerCase() !== "n");
-    });
-  });
-}
-function promptInput(prompt2) {
-  if (autoYes) return Promise.resolve("");
-  const rl = (0, import_node_readline3.createInterface)({ input: process.stdin, output: process.stdout });
-  return new Promise((res) => {
-    rl.question(import_chalk2.default.cyan(`${INDENT}${prompt2}`), (answer) => {
-      rl.close();
-      res(answer.trim());
-    });
-  });
-}
-var _isWSL = process.platform === "linux" && process.env.WSL_DISTRO_NAME;
-function formatClickablePath(filePath) {
-  const absolutePath = (0, import_node_path8.resolve)(filePath);
-  if (_isWSL) {
-    return absolutePath;
-  }
-  let formatted = absolutePath;
-  formatted = formatted.replace(/\//g, "\\");
-  if (formatted.includes(" ") && !formatted.startsWith('"')) {
-    formatted = `"${formatted}"`;
-  }
-  return formatted;
-}
-function formatDuration(ms) {
-  const mins = Math.floor(ms / 6e4);
-  const secs = Math.floor(ms % 6e4 / 1e3);
-  return `${mins}:${secs.toString().padStart(2, "0")}`;
-}
+async function logStep(stepNum, action, details) {
+  const detailsStr = Object.entries(details).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [STEP ${stepNum}] ${action} | ${detailsStr}
+`);
+}
 
 // src/commands/phases/video-phase.ts
-var import_node_fs11 = require("fs");
-var import_promises12 = require("fs/promises");
-var import_node_path17 = require("path");
+var import_node_fs12 = require("fs");
+var import_promises13 = require("fs/promises");
+var import_node_path18 = require("path");
 init_lib();
 
 // src/record.ts
-var import_node_fs9 = require("fs");
-var import_promises9 = require("fs/promises");
-var import_node_path14 = require("path");
-var import_chalk3 = __toESM(require("chalk"));
+var import_node_fs10 = require("fs");
+var import_promises10 = require("fs/promises");
+var import_node_path15 = require("path");
+var import_chalk6 = __toESM(require("chalk"));
 
 // src/browser/actions.ts
-var import_node_fs6 = require("fs");
-var import_promises6 = require("fs/promises");
-var import_node_path10 = require("path");
+var import_node_fs7 = require("fs");
+var import_promises7 = require("fs/promises");
+var import_node_path11 = require("path");
 
 // src/browser/effects.ts
-var import_node_fs5 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path10 = require("path");
 init_lib();
 function loadHighlightCSS() {
   const candidates = [
-    (0, import_node_path9.join)(__dirname, "highlight.css"),
+    (0, import_node_path10.join)(__dirname, "highlight.css"),
     // dist/ build
-    (0, import_node_path9.join)(__dirname, "..", "highlight.css")
+    (0, import_node_path10.join)(__dirname, "..", "highlight.css")
     // src/browser/ → src/
   ];
   for (const p of candidates) {
-    if ((0, import_node_fs5.existsSync)(p)) return (0, import_node_fs5.readFileSync)(p, "utf-8");
+    if ((0, import_node_fs6.existsSync)(p)) return (0, import_node_fs6.readFileSync)(p, "utf-8");
   }
   return "";
 }
@@ -3257,8 +3666,8 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
           const isPlaceholder = !rawPath || rawPath.startsWith("[") || rawPath.includes("example");
           if (!isPlaceholder) {
             const normalizedPath = rawPath.startsWith("mnt/") ? `/${rawPath}` : rawPath;
-            const filePath = (0, import_node_path10.isAbsolute)(normalizedPath) ? normalizedPath : (0, import_node_path10.resolve)(baseDir, normalizedPath);
-            if ((0, import_node_fs6.existsSync)(filePath)) {
+            const filePath = (0, import_node_path11.isAbsolute)(normalizedPath) ? normalizedPath : (0, import_node_path11.resolve)(baseDir, normalizedPath);
+            if ((0, import_node_fs7.existsSync)(filePath)) {
               await fileInput.setInputFiles(filePath);
               await page.waitForTimeout(2e3);
               break;
@@ -3374,8 +3783,8 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
     case "wait":
       break;
     case "image": {
-      const imagePath = step.value ? (0, import_node_path10.isAbsolute)(step.value) ? step.value : (0, import_node_path10.resolve)(baseDir, step.value) : null;
-      if (imagePath && (0, import_node_fs6.existsSync)(imagePath)) {
+      const imagePath = step.value ? (0, import_node_path11.isAbsolute)(step.value) ? step.value : (0, import_node_path11.resolve)(baseDir, step.value) : null;
+      if (imagePath && (0, import_node_fs7.existsSync)(imagePath)) {
         const imgStyle = step.target === "stretch" ? `width: ${config.video.width}px; height: ${config.video.height}px; object-fit: cover;` : "max-width: 90%; max-height: 90%;";
         if (await showImagePage(page, imagePath, imgStyle, config, cursorInjected)) injected = true;
       }
@@ -3405,7 +3814,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
         await pendingDownload;
         pendingDownload = null;
       }
-      if (lastDownloadPath && (0, import_node_fs6.existsSync)(lastDownloadPath)) {
+      if (lastDownloadPath && (0, import_node_fs7.existsSync)(lastDownloadPath)) {
         const imgStyle = step.target === "stretch" ? "width: 100%; height: 100%; object-fit: contain;" : "max-width: 90%; max-height: 90%; object-fit: contain;";
         if (await showImagePage(page, lastDownloadPath, imgStyle, config, cursorInjected)) injected = true;
       }
@@ -3416,7 +3825,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
 async function showImagePage(page, filePath, imgStyle, config, cursorInjected) {
   const { width, height } = config.video;
   const ext = filePath.split(".").pop()?.toLowerCase() || "";
-  const fileBuffer = await (0, import_promises6.readFile)(filePath);
+  const fileBuffer = await (0, import_promises7.readFile)(filePath);
   const base64 = fileBuffer.toString("base64");
   const mimeTypes = {
     png: "image/png",
@@ -3446,17 +3855,18 @@ async function showImagePage(page, filePath, imgStyle, config, cursorInjected) {
 }
 
 // src/browser/launch.ts
-var import_promises7 = require("fs/promises");
-var import_playwright4 = require("playwright");
-async function launchBrowserContext(config, userDataDir, recordVideo) {
+var import_promises8 = require("fs/promises");
+var import_playwright5 = require("playwright");
+async function launchBrowserContext(config, userDataDir, recordVideo, storageStatePath) {
   const extensionPath = config.browser?.extension;
   const viewport = { width: config.video.width, height: config.video.height };
   const videoOpts = recordVideo ? { recordVideo } : {};
+  const authOpts = storageStatePath ? { storageState: storageStatePath } : {};
   let context;
   let browser = null;
   let chromeSession = null;
   if (extensionPath) {
-    await (0, import_promises7.mkdir)(userDataDir, { recursive: true });
+    await (0, import_promises8.mkdir)(userDataDir, { recursive: true });
     const persistentArgs = [
       `--disable-extensions-except=${extensionPath}`,
       `--load-extension=${extensionPath}`,
@@ -3470,7 +3880,7 @@ async function launchBrowserContext(config, userDataDir, recordVideo) {
         const contexts = chromeSession.browser.contexts();
         context = contexts[0] || await chromeSession.browser.newContext({ viewport, ...videoOpts, acceptDownloads: true });
       } catch {
-        context = await import_playwright4.chromium.launchPersistentContext(userDataDir, {
+        context = await import_playwright5.chromium.launchPersistentContext(userDataDir, {
           headless: false,
           args: persistentArgs,
           viewport,
@@ -3479,7 +3889,7 @@ async function launchBrowserContext(config, userDataDir, recordVideo) {
         });
       }
     } else {
-      context = await import_playwright4.chromium.launchPersistentContext(userDataDir, {
+      context = await import_playwright5.chromium.launchPersistentContext(userDataDir, {
         headless: false,
         args: persistentArgs,
         viewport,
@@ -3488,8 +3898,8 @@ async function launchBrowserContext(config, userDataDir, recordVideo) {
       });
     }
   } else {
-    browser = await import_playwright4.chromium.launch({ headless: true });
-    context = await browser.newContext({ viewport, ...videoOpts, acceptDownloads: true });
+    browser = await import_playwright5.chromium.launch({ headless: true });
+    context = await browser.newContext({ viewport, ...videoOpts, ...authOpts, acceptDownloads: true });
   }
   return { context, browser, chromeSession };
 }
@@ -3506,23 +3916,23 @@ async function cleanupBrowserSession(session) {
 init_lib();
 
 // src/browser/dry-run.ts
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 init_utils();
 
 // src/browser/step-validator.ts
-var import_node_fs7 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path12 = require("path");
 init_utils();
 function findMediaFile(filename, baseDir) {
-  const name = (0, import_node_path11.basename)(filename);
-  const searchDirs = [baseDir, (0, import_node_path11.join)(baseDir, "res"), (0, import_node_path11.join)(baseDir, "assets"), (0, import_node_path11.join)(baseDir, "media")];
+  const name = (0, import_node_path12.basename)(filename);
+  const searchDirs = [baseDir, (0, import_node_path12.join)(baseDir, "res"), (0, import_node_path12.join)(baseDir, "assets"), (0, import_node_path12.join)(baseDir, "media")];
   for (const dir of searchDirs) {
-    if (!(0, import_node_fs7.existsSync)(dir)) continue;
+    if (!(0, import_node_fs8.existsSync)(dir)) continue;
     try {
-      const files = (0, import_node_fs7.readdirSync)(dir);
-      if (files.includes(name)) return (0, import_node_path11.join)(dir, name);
+      const files = (0, import_node_fs8.readdirSync)(dir);
+      if (files.includes(name)) return (0, import_node_path12.join)(dir, name);
       const match = files.find((f) => f.toLowerCase() === name.toLowerCase());
-      if (match) return (0, import_node_path11.join)(dir, match);
+      if (match) return (0, import_node_path12.join)(dir, match);
     } catch {
     }
   }
@@ -3594,8 +4004,8 @@ function resolveMediaStep(step, baseDir, label, startTime) {
   if (!step.value) {
     return { success: false, error: `Missing ${label} path`, executionTimeMs: Date.now() - startTime };
   }
-  const specifiedPath = (0, import_node_path11.isAbsolute)(step.value) ? step.value : (0, import_node_path11.resolve)(baseDir, step.value);
-  if ((0, import_node_fs7.existsSync)(specifiedPath)) return { success: true, executionTimeMs: Date.now() - startTime };
+  const specifiedPath = (0, import_node_path12.isAbsolute)(step.value) ? step.value : (0, import_node_path12.resolve)(baseDir, step.value);
+  if ((0, import_node_fs8.existsSync)(specifiedPath)) return { success: true, executionTimeMs: Date.now() - startTime };
   const foundPath = findMediaFile(step.value, baseDir);
   if (foundPath) {
     step.value = `./${foundPath.replace(`${baseDir}/`, "").replace(`${baseDir}\\`, "")}`;
@@ -3716,8 +4126,8 @@ async function validateAndExecuteStep(page, step, plan, baseDir) {
         const isPlaceholder = !rawPath || rawPath.startsWith("[") || rawPath.includes("example");
         if (!isPlaceholder) {
           const normalizedPath = rawPath.startsWith("mnt/") ? `/${rawPath}` : rawPath;
-          let filePath = (0, import_node_path11.isAbsolute)(normalizedPath) ? normalizedPath : (0, import_node_path11.resolve)(baseDir, normalizedPath);
-          if (!(0, import_node_fs7.existsSync)(filePath)) {
+          let filePath = (0, import_node_path12.isAbsolute)(normalizedPath) ? normalizedPath : (0, import_node_path12.resolve)(baseDir, normalizedPath);
+          if (!(0, import_node_fs8.existsSync)(filePath)) {
             const foundPath = findMediaFile(rawPath, baseDir);
             if (foundPath) {
               const relativePath = `./${foundPath.replace(`${baseDir}/`, "").replace(`${baseDir}\\`, "")}`;
@@ -3816,8 +4226,13 @@ async function getPageElements(page) {
   });
 }
 async function validateStepsOnPage(plan, config, logError2, baseDir, onStepStart, onStepEnd) {
-  const userDataDir = (0, import_node_path12.join)(baseDir, ".browser-data");
-  const { context, browser, chromeSession } = await launchBrowserContext(config, userDataDir);
+  const userDataDir = (0, import_node_path13.join)(baseDir, ".browser-data");
+  const { context, browser, chromeSession } = await launchBrowserContext(
+    config,
+    userDataDir,
+    void 0,
+    findAuthState(plan.url)
+  );
   const page = context.pages()[0] || await context.newPage();
   setupDownloadTracking(page);
   const results = [];
@@ -3876,27 +4291,27 @@ async function validateStepsOnPage(plan, config, logError2, baseDir, onStepStart
 }
 
 // src/browser/meta.ts
-var import_node_fs8 = require("fs");
-var import_promises8 = require("fs/promises");
-var import_node_path13 = require("path");
+var import_node_fs9 = require("fs");
+var import_promises9 = require("fs/promises");
+var import_node_path14 = require("path");
 var RECORDING_FILE = "recording.mp4";
 var RECORDING_META_FILE = "recording.meta.json";
 function getRecordingPath(outputDir) {
-  return (0, import_node_path13.join)(outputDir, RECORDING_FILE);
+  return (0, import_node_path14.join)(outputDir, RECORDING_FILE);
 }
 async function loadRecordingMeta(outputDir) {
-  const metaPath = (0, import_node_path13.join)(outputDir, RECORDING_META_FILE);
-  if (!(0, import_node_fs8.existsSync)(metaPath)) return null;
+  const metaPath = (0, import_node_path14.join)(outputDir, RECORDING_META_FILE);
+  if (!(0, import_node_fs9.existsSync)(metaPath)) return null;
   try {
-    const content = await (0, import_promises8.readFile)(metaPath, "utf-8");
+    const content = await (0, import_promises9.readFile)(metaPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 async function saveRecordingMeta(outputDir, meta) {
-  const metaPath = (0, import_node_path13.join)(outputDir, RECORDING_META_FILE);
-  await (0, import_promises8.writeFile)(metaPath, JSON.stringify(meta, null, 2));
+  const metaPath = (0, import_node_path14.join)(outputDir, RECORDING_META_FILE);
+  await (0, import_promises9.writeFile)(metaPath, JSON.stringify(meta, null, 2));
 }
 function canReuseRecording(plan, config, stepDurations, existingMeta) {
   if (!existingMeta) {
@@ -3965,16 +4380,17 @@ function formatStepLabel(step) {
   return `${caption.slice(0, 47)}...`;
 }
 async function recordSession(plan, config, stepDurations, workDir, baseDir, task2, logError2) {
-  const videoDir = (0, import_node_path14.join)(workDir, "video");
-  await (0, import_promises9.mkdir)(videoDir, { recursive: true });
+  const videoDir = (0, import_node_path15.join)(workDir, "video");
+  await (0, import_promises10.mkdir)(videoDir, { recursive: true });
   const getStepDuration = (stepNum) => {
     return stepDurations[stepNum - 1] ?? config.timing.minStepDuration;
   };
   const browserTask = task2("Starting browser recording");
   const recordingStartTime = Date.now();
-  const userDataDir = (0, import_node_path14.join)(workDir, "browser-data");
+  const userDataDir = (0, import_node_path15.join)(workDir, "browser-data");
   const recordVideo = { dir: videoDir, size: { width: config.video.width, height: config.video.height } };
-  const { context, browser, chromeSession } = await launchBrowserContext(config, userDataDir, recordVideo);
+  const authState = findAuthState(plan.url);
+  const { context, browser, chromeSession } = await launchBrowserContext(config, userDataDir, recordVideo, authState);
   const page = context.pages()[0] || await context.newPage();
   setupDownloadTracking(page);
   context.on("page", (p) => setupDownloadTracking(p));
@@ -4072,9 +4488,9 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
     actualStepDurations.push(actualDuration);
   }
   if (failures.length > 0) {
-    console.log(import_chalk3.default.yellow(`  \u26A0 ${failures.length} step(s) skipped:`));
+    console.log(import_chalk6.default.yellow(`  \u26A0 ${failures.length} step(s) skipped:`));
     for (const f of failures) {
-      console.log(import_chalk3.default.yellow(`    - ${f}`));
+      console.log(import_chalk6.default.yellow(`    - ${f}`));
     }
   }
   const saveTask = task2("Saving video");
@@ -4083,7 +4499,7 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
   await page.close();
   const videoPath = await video.path();
   await cleanupBrowserSession({ context, browser, chromeSession });
-  if (!videoPath || !(0, import_node_fs9.existsSync)(videoPath)) {
+  if (!videoPath || !(0, import_node_fs10.existsSync)(videoPath)) {
     throw new Error("Video file was not created");
   }
   saveTask.succeed("Video saved");
@@ -4091,33 +4507,18 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
 }
 
 // src/utils/video-pipeline.ts
-var import_node_fs10 = require("fs");
-var import_promises10 = require("fs/promises");
-var import_node_path15 = require("path");
+var import_video_kit6 = require("@spark-apps/video-kit");
+var import_node_fs11 = require("fs");
+var import_promises11 = require("fs/promises");
+var import_node_path16 = require("path");
+var import_chalk7 = __toESM(require("chalk"));
 init_lib();
 var INDENT2 = "   ";
-function chunkWords(words, maxWords) {
-  const chunks = [];
-  for (let i = 0; i < words.length; i += maxWords) {
-    chunks.push(words.slice(i, i + maxWords));
-  }
-  return chunks;
-}
-function formatASSTime(ms) {
-  const hours = Math.floor(ms / 36e5);
-  const minutes = Math.floor(ms % 36e5 / 6e4);
-  const seconds = Math.floor(ms % 6e4 / 1e3);
-  const centis = Math.floor(ms % 1e3 / 10);
-  return `${hours}:${pad(minutes)}:${pad(seconds)}.${pad(centis)}`;
-}
-function pad(n, len = 2) {
-  return n.toString().padStart(len, "0");
-}
 async function generateASS(plan, stepAudio, workDir, config, captions) {
-  const regularColor = hexToASS(captions.regular.color);
-  const highlightColor = hexToASS(captions.highlight.color);
-  const outline = hexToASS(captions.outline);
-  const back = hexToASS(captions.outline, 128);
+  const regularColor = (0, import_video_kit.hexToAss)(captions.regular.color);
+  const highlightColor = (0, import_video_kit.hexToAss)(captions.highlight.color);
+  const outline = (0, import_video_kit.hexToAss)(captions.outline);
+  const back = (0, import_video_kit.hexToAss)(captions.outline, 128);
   const highlightScale = Math.round(captions.highlight.size / captions.regular.size * 100);
   let ass = generateASSHeader(
     config.video.width,
@@ -4142,7 +4543,7 @@ async function generateASS(plan, stepAudio, workDir, config, captions) {
       continue;
     }
     const words = audio.words.length > 0 ? audio.words : estimateWordTimings(step.caption || "", audio.duration);
-    const chunks = chunkWords(words, 3);
+    const chunks = (0, import_video_kit6.chunkWordsByCount)(words, 3);
     for (const chunk of chunks) {
       if (chunk.length === 0) continue;
       const chunkStart = currentTime + chunk[0].start;
@@ -4153,13 +4554,13 @@ async function generateASS(plan, stepAudio, workDir, config, captions) {
         const duration = Math.round((word.end - word.start) / 10);
         karaokeText += `{\\kf${duration}\\fscx${highlightScale}\\fscy${highlightScale}}${word.word}{\\fscx100\\fscy100} `;
       }
-      ass += `Dialogue: 0,${formatASSTime(chunkStart)},${formatASSTime(chunkEnd)},Karaoke,,0,0,0,,${karaokeText.trim()}
+      ass += `Dialogue: 0,${(0, import_video_kit6.assTimeFromMs)(chunkStart)},${(0, import_video_kit6.assTimeFromMs)(chunkEnd)},Karaoke,,0,0,0,,${karaokeText.trim()}
 `;
     }
     currentTime += audio.duration;
   }
-  const assPath = (0, import_node_path15.join)(workDir, "subtitles.ass");
-  await (0, import_promises10.writeFile)(assPath, ass);
+  const assPath = (0, import_node_path16.join)(workDir, "subtitles.ass");
+  await (0, import_promises11.writeFile)(assPath, ass);
   return assPath;
 }
 function buildVideoOverlays(steps, stepDurations, baseDir) {
@@ -4172,8 +4573,8 @@ function buildVideoOverlays(steps, stepDurations, baseDir) {
     if ((step.action === "video" || step.action === "media") && step.value) {
       const ext = step.value.split(".").pop()?.toLowerCase() || "";
       if (["mp4", "webm", "mov"].includes(ext)) {
-        const mediaPath = (0, import_node_path15.isAbsolute)(step.value) ? step.value : (0, import_node_path15.resolve)(baseDir, step.value);
-        if ((0, import_node_fs10.existsSync)(mediaPath)) {
+        const mediaPath = (0, import_node_path16.isAbsolute)(step.value) ? step.value : (0, import_node_path16.resolve)(baseDir, step.value);
+        if ((0, import_node_fs11.existsSync)(mediaPath)) {
           const partial = parsePartial(step.partial);
           overlays.push({
             path: mediaPath,
@@ -4192,23 +4593,23 @@ function buildVideoOverlays(steps, stepDurations, baseDir) {
 }
 async function composeAndFinish(videoPath, audioPath, assPath, config, userTier = "free", mainContentDuration, trimStart = 0.5, stepTransitions, _stepSync) {
   header("Compose");
-  const configPath = (0, import_node_path15.join)(process.cwd(), CONFIG_FILE);
-  console.log(`${INDENT2}${require("chalk").dim(`Config: ${formatClickablePath(configPath)}`)}`);
+  const configPath = (0, import_node_path16.join)(process.cwd(), CONFIG_FILE);
+  console.log(`${INDENT2}${import_chalk7.default.dim(`Config: ${formatClickablePath(configPath)}`)}`);
   const proceed = await confirm(`${INDENT2}Review config or continue?`);
   if (!proceed) {
-    console.log(require("chalk").yellow(`
+    console.log(import_chalk7.default.yellow(`
   Edit ${CONFIG_FILE} and run again.
 `));
     process.exit(0);
   }
   const composeTask = task("Building final video");
-  await (0, import_promises10.mkdir)(config.output.dir, { recursive: true });
+  await (0, import_promises11.mkdir)(config.output.dir, { recursive: true });
   const suffix = config.lang ? `-${config.lang}` : "";
-  const finalPath = (0, import_node_path15.join)(config.output.dir, `demo${suffix}.${config.video.format}`);
+  const finalPath = (0, import_node_path16.join)(config.output.dir, `demo${suffix}.${config.video.format}`);
   const videoDuration = await getMediaDuration(videoPath) / 1e3;
-  const hasVoiceover = audioPath && (0, import_node_fs10.existsSync)(audioPath);
-  const musicPath = config.music?.path ? (0, import_node_path15.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path15.resolve)(config.output.dir, config.music.path) : "";
-  const hasMusic = musicPath && (0, import_node_fs10.existsSync)(musicPath);
+  const hasVoiceover = audioPath && (0, import_node_fs11.existsSync)(audioPath);
+  const musicPath = config.music?.path ? (0, import_node_path16.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path16.resolve)(config.output.dir, config.music.path) : "";
+  const hasMusic = musicPath && (0, import_node_fs11.existsSync)(musicPath);
   try {
     await composeVideo({
       videoPath,
@@ -4245,10 +4646,9 @@ async function composeAndFinish(videoPath, audioPath, assPath, config, userTier
 async function speedUpToFitLimit(finalPath, config, limitSecs = 60) {
   const duration = await getMediaDuration(finalPath);
   if (duration <= limitSecs * 1e3) return finalPath;
-  const chalk17 = require("chalk");
   const speedFactor = Math.ceil(duration / (limitSecs * 1e3) * 10) / 10;
   console.log();
-  console.log(chalk17.yellow(`  Video is ${(duration / 1e3).toFixed(0)}s - over ${limitSecs}s`));
+  console.log(import_chalk7.default.yellow(`  Video is ${(duration / 1e3).toFixed(0)}s - over ${limitSecs}s`));
   const speedUp = await confirm(`  Speed up ${speedFactor}x to fit under ${limitSecs}s?`);
   if (!speedUp) return finalPath;
   const speedTask = task(`Speeding up ${speedFactor}x`);
@@ -4270,23 +4670,23 @@ async function speedUpToFitLimit(finalPath, config, limitSecs = 60) {
 }
 
 // src/commands/utils/record-helpers.ts
-var import_chalk5 = __toESM(require("chalk"));
+var import_chalk9 = __toESM(require("chalk"));
 init_lib();
 
 // src/plan.ts
-var import_promises11 = require("fs/promises");
-var import_node_path16 = require("path");
-var import_chalk4 = __toESM(require("chalk"));
-var import_playwright5 = require("playwright");
+var import_promises12 = require("fs/promises");
+var import_node_path17 = require("path");
+var import_chalk8 = __toESM(require("chalk"));
+var import_playwright6 = require("playwright");
 init_lib();
 async function crawlExtension(url, extensionPath, workDir, task2) {
   const browserTask = task2("Launching browser with extension");
-  const userDataDir = (0, import_node_path16.join)(workDir, ".browser-data");
-  await (0, import_promises11.mkdir)(userDataDir, { recursive: true });
+  const userDataDir = (0, import_node_path17.join)(workDir, ".browser-data");
+  await (0, import_promises12.mkdir)(userDataDir, { recursive: true });
   let context;
   let chromeSession = null;
   const useWindowsChrome = isWSL() && tryEnableWSLInterop();
-  const launchPersistent = () => import_playwright5.chromium.launchPersistentContext(userDataDir, {
+  const launchPersistent = () => import_playwright6.chromium.launchPersistentContext(userDataDir, {
     headless: false,
     args: [
       `--disable-extensions-except=${extensionPath}`,
@@ -4302,7 +4702,7 @@ async function crawlExtension(url, extensionPath, workDir, task2) {
       const contexts = chromeSession.browser.contexts();
       context = contexts[0] || await chromeSession.browser.newContext({ viewport: { width: 400, height: 600 } });
     } catch (_err) {
-      console.log(import_chalk4.default.yellow("  \u26A0 Windows Chrome unavailable, using Chromium"));
+      console.log(import_chalk8.default.yellow("  \u26A0 Windows Chrome unavailable, using Chromium"));
       context = await launchPersistent();
     }
   } else {
@@ -4379,8 +4779,34 @@ async function crawlExtension(url, extensionPath, workDir, task2) {
   crawlTask.succeed(`Found ${elements.length} interactive elements`);
   return { title, elements };
 }
+var JSON_FIX_SYSTEM_PROMPT = "You fix malformed JSON. Return ONLY valid JSON, no explanation.";
+var jsonFixUserPrompt = (content) => `Fix this malformed JSON plan. Return ONLY valid JSON, no explanation.
+The JSON should have: url, title, description, steps array.
+Each step has: id (number), action, caption, and optionally target, value.
+
+Malformed content:
+${content}`;
+async function parsePlanJson(content, task2, logError2, userEmail, tier = "free") {
+  try {
+    return JSON.parse(content);
+  } catch {
+    const fixTask = task2("Fixing malformed JSON");
+    try {
+      const fixed = await callGroq(JSON_FIX_SYSTEM_PROMPT, jsonFixUserPrompt(content), logError2, userEmail, tier);
+      const jsonMatch = fixed.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) throw new Error("No JSON in fix");
+      const plan = JSON.parse(jsonMatch[0]);
+      fixTask.succeed("JSON fixed by AI");
+      return plan;
+    } catch (err) {
+      await logError2("JSON Fix", err);
+      fixTask.fail("Could not fix JSON");
+      throw new Error(`Malformed JSON: ${getErrorMessage(err)}`);
+    }
+  }
+}
 async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError2, userEmail, extensionPath, workDir, tier = "free") {
-  const { title, elements } = extensionPath && workDir ? await crawlExtension(url, extensionPath, workDir, task2) : await crawlPage(url, task2);
+  const { title, elements } = extensionPath && workDir ? await crawlExtension(url, extensionPath, workDir, task2) : await crawlPage(url, task2, findAuthState(url));
   const aiTask = task2("Generating plan with AI");
   const langName = getLanguageName(lang);
   const systemPrompt = buildSystemPrompt(maxSteps);
@@ -4389,7 +4815,7 @@ async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError
     const content = await callGroq(systemPrompt, userPrompt, logError2, userEmail, tier);
     const jsonMatch = content.match(/\{[\s\S]*\}/);
     if (!jsonMatch) throw new Error("No JSON found in response");
-    const plan = JSON.parse(jsonMatch[0]);
+    const plan = await parsePlanJson(jsonMatch[0], task2, logError2, userEmail, tier);
     if (lang !== void 0) plan.lang = lang;
     plan.steps = plan.steps.map(({ duration, ...s }, i) => ({
       ...s,
@@ -4406,36 +4832,8 @@ async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError
   }
 }
 async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier = "free") {
-  const content = await (0, import_promises11.readFile)(planPath, "utf-8");
-  let plan;
-  try {
-    plan = JSON.parse(content);
-  } catch (_parseError) {
-    const fixTask = task2("Fixing malformed JSON");
-    checkCredentials();
-    try {
-      const fixed = await callGroq(
-        "You fix malformed JSON. Return ONLY valid JSON, no explanation.",
-        `Fix this malformed JSON plan. Return ONLY valid JSON, no explanation.
-The JSON should have: url, title, description, steps array.
-Each step has: id (number), action, caption, and optionally target, value.
-
-Malformed content:
-${content}`,
-        logError2,
-        userEmail,
-        tier
-      );
-      const jsonMatch = fixed.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) throw new Error("No JSON in fix");
-      plan = JSON.parse(jsonMatch[0]);
-      fixTask.succeed("JSON fixed by AI");
-    } catch (err) {
-      await logError2("JSON Fix", err);
-      fixTask.fail("Could not fix JSON");
-      throw new Error(`Malformed JSON: ${getErrorMessage(err)}`);
-    }
-  }
+  const content = await (0, import_promises12.readFile)(planPath, "utf-8");
+  const plan = await parsePlanJson(content, task2, logError2, userEmail, tier);
   if (!plan.url || !plan.steps || !Array.isArray(plan.steps)) {
     throw new Error("Invalid plan: missing url or steps");
   }
@@ -4467,7 +4865,7 @@ ${content}`,
     renumberTask.fail("No valid steps");
     throw new Error("Plan has no valid steps");
   }
-  await (0, import_promises11.writeFile)(planPath, JSON.stringify(plan, null, 2));
+  await (0, import_promises12.writeFile)(planPath, JSON.stringify(plan, null, 2));
   const removed = originalCount - plan.steps.length;
   renumberTask.succeed(
     removed > 0 ? `${plan.steps.length} steps (${removed} removed)` : `${plan.steps.length} steps validated`
@@ -4499,31 +4897,41 @@ function displayRateLimitInfo() {
   const percentage = Math.round(limits.used / limits.limit * 100);
   if (percentage >= 90) {
     console.log();
-    console.log(import_chalk5.default.yellow(`  \u26A0 ${remaining} requests remaining (${limits.tier} tier)`));
+    console.log(import_chalk9.default.yellow(`  \u26A0 ${remaining} requests remaining (${limits.tier} tier)`));
     if (limits.tier === "free") {
-      console.log(import_chalk5.default.dim(`    Upgrade: ${getUpgradeUrl()}`));
+      console.log(import_chalk9.default.dim(`    Upgrade: ${getUpgradeUrl()}`));
     }
   } else if (percentage >= 50) {
-    console.log(import_chalk5.default.dim(`  ${remaining}/${limits.limit} requests remaining`));
+    console.log(import_chalk9.default.dim(`  ${remaining}/${limits.limit} requests remaining`));
   }
 }
-function displayUsageStatus(userEmail, userTier, localVideoCount = 0) {
-  const tierLabel = userTier === "pro" ? "Pro" : "Free";
-  const used = localVideoCount + 1;
-  console.log(import_chalk5.default.cyan(`    \u2714 ${tierLabel} tier (${used}/${FREE_VIDEO_LIMIT})`));
+async function displayUsageStatus(userEmail, userTier, _localVideoCount = 0) {
+  const tier = userTier === "pro" ? "pro" : "free";
+  const tierLabel = tier === "pro" ? import_chalk9.default.green("Pro") : "Free";
+  console.log(import_chalk9.default.cyan(`    \u2714 ${tierLabel} plan`));
+  console.log(import_chalk9.default.dim(`      ${userEmail}`));
+  if (userEmail && userEmail !== "anonymous") {
+    try {
+      const status = await getStatusCached(userEmail);
+      for (const line of formatUsageLines(status, tier)) {
+        console.log(import_chalk9.default.dim(`      ${line}`));
+      }
+    } catch {
+    }
+  }
   if (userTier === "free") {
     const upgradeUrl = getUpgradeUrl(userEmail !== "anonymous" ? userEmail : void 0);
-    console.log(import_chalk5.default.dim(`      Upgrade: ${upgradeUrl}`));
+    console.log(import_chalk9.default.dim(`      Upgrade: ${upgradeUrl}`));
   }
 }
 function displayPlanSummary(plan) {
   console.log();
-  console.log(import_chalk5.default.dim(`  ${plan.title || "Untitled"}`));
-  console.log(import_chalk5.default.dim(`  ${plan.steps?.length || 0} steps`));
+  console.log(import_chalk9.default.dim(`  ${plan.title || "Untitled"}`));
+  console.log(import_chalk9.default.dim(`  ${plan.steps?.length || 0} steps`));
   for (const step of plan.steps || []) {
     const text = step.caption || step.action || "";
     const caption = text.length > 50 ? `${text.slice(0, 47)}...` : text;
-    console.log(import_chalk5.default.dim(`    ${step.id}. ${caption}`));
+    console.log(import_chalk9.default.dim(`    ${step.id}. ${caption}`));
   }
 }
 function getOutputDirFromUrl(url) {
@@ -4589,8 +4997,8 @@ async function runVideoPhase(params) {
             if (trimStart2 !== void 0 && trimEnd !== void 0) {
               mediaDuration = (trimEnd - trimStart2) * 1e3;
             } else {
-              const mediaPath = (0, import_node_path17.resolve)(s.value);
-              if ((0, import_node_fs11.existsSync)(mediaPath)) {
+              const mediaPath = (0, import_node_path18.resolve)(s.value);
+              if ((0, import_node_fs12.existsSync)(mediaPath)) {
                 try {
                   const fullDuration = await getMediaDuration(mediaPath);
                   const start = (trimStart2 ?? 0) * 1e3;
@@ -4601,8 +5009,8 @@ async function runVideoPhase(params) {
               }
             }
           } else {
-            const mediaPath = (0, import_node_path17.resolve)(s.value);
-            if ((0, import_node_fs11.existsSync)(mediaPath)) {
+            const mediaPath = (0, import_node_path18.resolve)(s.value);
+            if ((0, import_node_fs12.existsSync)(mediaPath)) {
               try {
                 mediaDuration = await getMediaDuration(mediaPath);
               } catch {
@@ -4615,7 +5023,7 @@ async function runVideoPhase(params) {
     })
   );
   const recordingPath = getRecordingPath(config.output.dir);
-  const hasExistingRecording = existingRecordingMeta && (0, import_node_fs11.existsSync)(recordingPath);
+  const hasExistingRecording = existingRecordingMeta && (0, import_node_fs12.existsSync)(recordingPath);
   let videoPath = recordingPath;
   const firstStep = plan.steps[0];
   const firstStepIsVideo = firstStep && (firstStep.action === "video" || firstStep.action === "media");
@@ -4624,7 +5032,7 @@ async function runVideoPhase(params) {
     header("Record");
     const result = await recordSession(plan, config, stepDurations, workDir, config.output.dir, task, logError);
     stepAudio = await alignVoiceoverToRecording(stepAudio, result.actualStepDurations, workDir, config.output.dir);
-    await (0, import_promises12.copyFile)(result.videoPath, recordingPath);
+    await (0, import_promises13.copyFile)(result.videoPath, recordingPath);
     const meta = buildRecordingMeta(plan, config, result.actualStepDurations);
     meta.pageLoadTime = result.pageLoadTime;
     await saveRecordingMeta(config.output.dir, meta);
@@ -4655,7 +5063,7 @@ async function runVideoPhase(params) {
   if (videoOverlays.length > 0) {
     const spliceTask = task("Splicing videos into recording");
     try {
-      const splicedPath = (0, import_node_path17.join)(workDir, "spliced.mp4");
+      const splicedPath = (0, import_node_path18.join)(workDir, "spliced.mp4");
       await spliceVideos({
         inputPath: videoPath,
         outputPath: splicedPath,
@@ -4675,7 +5083,7 @@ async function runVideoPhase(params) {
   if (stepTransitions.length > 0) {
     const transitionTask = task("Applying transitions");
     try {
-      const transitionedPath = (0, import_node_path17.join)(workDir, "transitioned.mp4");
+      const transitionedPath = (0, import_node_path18.join)(workDir, "transitioned.mp4");
       const videoDuration = alignedStepDurations.reduce((a, b) => a + b, 0) / 1e3;
       await applyTransitions({
         inputVideo: videoPath,
@@ -4696,15 +5104,15 @@ async function runVideoPhase(params) {
   let mainContentDuration;
   if (userTier === "free") {
     const scriptDir = getScriptDir();
-    let outroPath = (0, import_node_path17.join)(scriptDir, "assets", "qp.wm");
-    if (!(0, import_node_fs11.existsSync)(outroPath)) {
-      outroPath = (0, import_node_path17.join)(scriptDir, "..", "dist", "assets", "qp.wm");
+    let outroPath = (0, import_node_path18.join)(scriptDir, "assets", "qp.wm");
+    if (!(0, import_node_fs12.existsSync)(outroPath)) {
+      outroPath = (0, import_node_path18.join)(scriptDir, "..", "dist", "assets", "qp.wm");
     }
-    if ((0, import_node_fs11.existsSync)(outroPath)) {
+    if ((0, import_node_fs12.existsSync)(outroPath)) {
       try {
         const mainDuration = await getMediaDuration(videoPath);
         mainContentDuration = mainDuration / 1e3 - trimStart;
-        const combinedPath = (0, import_node_path17.join)(workDir, "combined-with-outro.mp4");
+        const combinedPath = (0, import_node_path18.join)(workDir, "combined-with-outro.mp4");
         await concatVideoWithOutro({
           inputPath: videoPath,
           outroPath,
@@ -4751,19 +5159,19 @@ async function runVideoPhase(params) {
 }
 
 // src/commands/phases/voiceover-phase.ts
-var import_node_fs12 = require("fs");
-var import_node_path18 = require("path");
-var import_chalk6 = __toESM(require("chalk"));
+var import_node_fs13 = require("fs");
+var import_node_path19 = require("path");
+var import_chalk10 = __toESM(require("chalk"));
 init_lib();
 var INDENT5 = "   ";
 async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
   if (fresh) {
     const filesToDelete = ["voiceover.json", "voiceover.wav", "recording.meta.json"];
     for (const file of filesToDelete) {
-      const filePath = (0, import_node_path18.join)(config.output.dir, file);
-      if ((0, import_node_fs12.existsSync)(filePath)) {
-        const { unlink: unlink2 } = await import("fs/promises");
-        await unlink2(filePath).catch(() => {
+      const filePath = (0, import_node_path19.join)(config.output.dir, file);
+      if ((0, import_node_fs13.existsSync)(filePath)) {
+        const { unlink: unlink3 } = await import("fs/promises");
+        await unlink3(filePath).catch(() => {
         });
       }
     }
@@ -4771,8 +5179,8 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
   }
   const voice = resolveVoice(config);
   const existingMeta = await loadVoiceoverMeta(config.output.dir);
-  const voiceoverFile = (0, import_node_path18.join)(config.output.dir, "voiceover.wav");
-  const hasExistingVoiceover = existingMeta && (0, import_node_fs12.existsSync)(voiceoverFile);
+  const voiceoverFile = (0, import_node_path19.join)(config.output.dir, "voiceover.wav");
+  const hasExistingVoiceover = existingMeta && (0, import_node_fs13.existsSync)(voiceoverFile);
   const voiceMatches = !existingMeta || !voice || existingMeta.voice === voice;
   let voiceoverPath;
   let stepAudio;
@@ -4795,9 +5203,9 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
     const reuseCheck = canReuseVoiceover(plan.steps, voice, existingMeta);
     if (reuseCheck.canReuse) {
       console.log();
-      console.log(import_chalk6.default.dim(`  Found existing voiceover in ${config.output.dir}`));
+      console.log(import_chalk10.default.dim(`  Found existing voiceover in ${config.output.dir}`));
       if (reuseCheck.reason) {
-        console.log(import_chalk6.default.dim(`  ${reuseCheck.reason}`));
+        console.log(import_chalk10.default.dim(`  ${reuseCheck.reason}`));
       }
       const reuse = await confirm(`${INDENT5}Reuse existing voiceover?`);
       if (reuse) {
@@ -4837,7 +5245,7 @@ async function captureCommand(url, lang) {
   const captureResult = await captureUserSession(url, workDir);
   info(`Captured ${captureResult.events.length} interactions over ${(captureResult.durationMs / 1e3).toFixed(0)}s`);
   if (captureResult.events.length === 0) {
-    console.log(import_chalk7.default.yellow("  No interactions captured. Exiting."));
+    console.log(import_chalk11.default.yellow("  No interactions captured. Exiting."));
     return;
   }
   header("Convert");
@@ -4845,7 +5253,7 @@ async function captureCommand(url, lang) {
   const rawSteps = eventsToSteps(captureResult.events, url);
   if (rawSteps.length === 0) {
     convertTask.fail("No actionable steps found");
-    console.log(import_chalk7.default.yellow("  No actionable steps could be derived from the captured events."));
+    console.log(import_chalk11.default.yellow("  No actionable steps could be derived from the captured events."));
     return;
   }
   convertTask.succeed(`${rawSteps.length} steps extracted`);
@@ -4877,16 +5285,16 @@ async function captureCommand(url, lang) {
     ...lang !== void 0 ? { lang } : {},
     steps
   };
-  const planPath = (0, import_node_path19.join)(config.output.dir, `plan-${lang ?? "en"}.json`);
+  const planPath = (0, import_node_path20.join)(config.output.dir, `plan-${lang ?? "en"}.json`);
   await savePlan(plan, planPath);
   console.log();
-  console.log(import_chalk7.default.bold.green(`  Plan saved: ${planPath}`));
-  console.log(import_chalk7.default.dim(`  Run: qp ${url}  to replay and create a polished demo video`));
+  console.log(import_chalk11.default.bold.green(`  Plan saved: ${planPath}`));
+  console.log(import_chalk11.default.dim(`  Run: qp ${url}  to replay and create a polished demo video`));
   console.log();
   const makeVideo = await confirm("   Create polished demo video now?");
   if (!makeVideo) {
     console.log();
-    console.log(import_chalk7.default.dim(`  Run: qp ${url}  anytime to create a video from this plan.`));
+    console.log(import_chalk11.default.dim(`  Run: qp ${url}  anytime to create a video from this plan.`));
     return;
   }
   header("Voiceover");
@@ -4902,20 +5310,20 @@ async function captureCommand(url, lang) {
     userTier
   });
   console.log();
-  console.log(import_chalk7.default.bold.green("  Done!"));
-  console.log(import_chalk7.default.cyan(`  ${finalPath}`));
+  console.log(import_chalk11.default.bold.green("  Done!"));
+  console.log(import_chalk11.default.cyan(`  ${finalPath}`));
 }
 
 // src/commands/init-cmd.ts
-var import_node_fs13 = require("fs");
-var import_promises13 = require("fs/promises");
-var import_node_path20 = require("path");
-var import_chalk8 = __toESM(require("chalk"));
+var import_node_fs14 = require("fs");
+var import_promises14 = require("fs/promises");
+var import_node_path21 = require("path");
+var import_chalk12 = __toESM(require("chalk"));
 init_lib();
 async function initCommand() {
-  const configPath = (0, import_node_path20.join)(process.cwd(), CONFIG_FILE);
-  if ((0, import_node_fs13.existsSync)(configPath)) {
-    console.log(import_chalk8.default.yellow(`  \u26A0 ${CONFIG_FILE} already exists`));
+  const configPath = (0, import_node_path21.join)(process.cwd(), CONFIG_FILE);
+  if ((0, import_node_fs14.existsSync)(configPath)) {
+    console.log(import_chalk12.default.yellow(`  \u26A0 ${CONFIG_FILE} already exists`));
     return;
   }
   const defaultConfig = {
@@ -4938,32 +5346,32 @@ async function initCommand() {
       volume: 0.3
     }
   };
-  await (0, import_promises13.writeFile)(configPath, `${JSON.stringify(defaultConfig, null, 2)}
+  await (0, import_promises14.writeFile)(configPath, `${JSON.stringify(defaultConfig, null, 2)}
 `);
-  console.log(import_chalk8.default.green(`  \u2714 Created ${CONFIG_FILE}`));
-  console.log(import_chalk8.default.dim(`  Edit it or use: qp config <key> <value>`));
+  console.log(import_chalk12.default.green(`  \u2714 Created ${CONFIG_FILE}`));
+  console.log(import_chalk12.default.dim(`  Edit it or use: qp config <key> <value>`));
 }
 async function configCommand(key, value) {
-  const configPath = (0, import_node_path20.join)(process.cwd(), CONFIG_FILE);
+  const configPath = (0, import_node_path21.join)(process.cwd(), CONFIG_FILE);
   if (!key) {
-    if (!(0, import_node_fs13.existsSync)(configPath)) {
-      console.log(import_chalk8.default.yellow(`  No ${CONFIG_FILE} found. Run: qp init`));
+    if (!(0, import_node_fs14.existsSync)(configPath)) {
+      console.log(import_chalk12.default.yellow(`  No ${CONFIG_FILE} found. Run: qp init`));
       return;
     }
-    const content = await (0, import_promises13.readFile)(configPath, "utf-8");
-    console.log(import_chalk8.default.cyan(`  ${CONFIG_FILE}:`));
+    const content = await (0, import_promises14.readFile)(configPath, "utf-8");
+    console.log(import_chalk12.default.cyan(`  ${CONFIG_FILE}:`));
     console.log(content);
     return;
   }
   if (!value) {
-    console.log(import_chalk8.default.red(`  Missing value for ${key}`));
-    console.log(import_chalk8.default.dim(`  Usage: qp config ${key} <value>`));
+    console.log(import_chalk12.default.red(`  Missing value for ${key}`));
+    console.log(import_chalk12.default.dim(`  Usage: qp config ${key} <value>`));
     return;
   }
   let config = {};
-  if ((0, import_node_fs13.existsSync)(configPath)) {
+  if ((0, import_node_fs14.existsSync)(configPath)) {
     try {
-      config = JSON.parse(await (0, import_promises13.readFile)(configPath, "utf-8"));
+      config = JSON.parse(await (0, import_promises14.readFile)(configPath, "utf-8"));
     } catch {
     }
   }
@@ -4985,124 +5393,101 @@ async function configCommand(key, value) {
     }
     obj[keys[keys.length - 1]] = parsedValue;
   }
-  await (0, import_promises13.writeFile)(configPath, `${JSON.stringify(config, null, 2)}
+  await (0, import_promises14.writeFile)(configPath, `${JSON.stringify(config, null, 2)}
 `);
-  console.log(import_chalk8.default.green(`  \u2714 Set ${key} = ${value}`));
+  console.log(import_chalk12.default.green(`  \u2714 Set ${key} = ${value}`));
 }
 
-// src/commands/record-cmd.ts
-var import_node_fs16 = require("fs");
-var import_promises16 = require("fs/promises");
-var import_node_path23 = require("path");
-var import_chalk14 = __toESM(require("chalk"));
-
-// src/help.ts
-var import_chalk9 = __toESM(require("chalk"));
+// src/commands/login-cmd.ts
+var import_chalk13 = __toESM(require("chalk"));
 init_lib();
-
-// src/logo.ts
-var import_figlet = __toESM(require("figlet"));
-var import_gradient_string = __toESM(require("gradient-string"));
-var DEFAULT_LOGO_CONFIG = {
-  text: "QuickPeek",
-  font: "Slant",
-  horizontalLayout: "default",
-  gradientColors: ["#00ffff", "#00d4ff", "#a855f7", "#ec4899"],
-  suffix: " \u{1F440}"
-};
-function renderLogo(config = {}) {
-  const resolved = { ...DEFAULT_LOGO_CONFIG, ...config };
-  const ascii = import_figlet.default.textSync(resolved.text, {
-    font: resolved.font,
-    horizontalLayout: resolved.horizontalLayout
-  });
-  const colored = (0, import_gradient_string.default)(resolved.gradientColors)(ascii);
-  return resolved.suffix ? `${colored}${resolved.suffix}` : colored;
-}
-
-// src/help.ts
-var cmd = import_chalk9.default.cyan;
-var arg = import_chalk9.default.green;
-var opt = import_chalk9.default.magenta;
-var desc = import_chalk9.default.white;
-var ex = import_chalk9.default.dim;
-function pad2(colored, visible, width) {
-  return colored + " ".repeat(Math.max(0, width - visible.length));
-}
-function showLogo() {
-  const logo = renderLogo();
-  console.log(logo);
-  console.log(import_chalk9.default.dim(`  v${VERSION} - Auto-generate demo videos with AI`));
-  console.log(import_chalk9.default.italic.dim("  Because Tutorial Videos are Overrated!\n"));
-}
-function showHelp() {
-  showLogo();
-  const W = 28;
-  const usage = [
-    [`${cmd("qp")} ${arg("<url>")}`, `qp <url>`, "AI-generated demo video"],
-    [`${cmd("qp")} ${arg("<url>")} ${opt("--script")} ${arg("<file>")}`, `qp <url> --script <file>`, "Use your own narration script"],
-    [`${cmd("qp capture")} ${arg("<url>")}`, `qp capture <url>`, "Record interactions manually"],
-    [`${cmd("qp init")}`, `qp init`, "Create config file"],
-    [`${cmd("qp config")} ${arg("<key>")} ${arg("<value>")}`, `qp config <key> <value>`, "Update a config option"]
-  ];
-  const options = [
-    [`${opt("lang=")}${arg("xx")}`, `lang=xx`, "Voice language (en, es, ar, zh, fr, de, ja...)"],
-    [`${opt("-d")}, ${opt("--description")} ${arg('"..."')}`, `-d, --description "..."`, "Guide AI with an app description"],
-    [`${opt("-s")}, ${opt("--script")} ${arg("<file>")}`, `-s, --script <file>`, "Narration script (one caption per line)"],
-    [`${opt("-y")}, ${opt("--yes")}`, `-y, --yes`, "Skip confirmation prompts"],
-    [`${opt("--skip-voice")}, ${opt("-sv")}`, `--skip-voice, -sv`, "Reuse existing voiceover"],
-    [`${opt("-f")}, ${opt("--fresh")}`, `-f, --fresh`, "Clear cached voiceover and recording"]
-  ];
-  const examples = [
-    `${ex("$")} ${cmd("qp")} ${arg("localhost:3000")}`,
-    `${ex("$")} ${cmd("qp")} ${arg("myapp.com")} ${opt("lang=")}${arg("es")} ${opt("-d")} ${arg('"E-commerce checkout flow"')}`,
-    `${ex("$")} ${cmd("qp")} ${arg("myapp.com")} ${opt("--script")} ${arg("narration.txt")}`,
-    `${ex("$")} ${cmd("qp capture")} ${arg("localhost:3000")}`
-  ];
+async function loginCommand() {
   console.log();
-  console.log(import_chalk9.default.yellow.bold("USAGE"));
-  for (const [colored, plain, d] of usage) {
-    console.log(`  ${pad2(colored, plain, W)}${desc(d)}`);
+  showLogo();
+  const existing = await loadUserData();
+  if (existing.email && existing.verified) {
+    console.log(import_chalk13.default.dim(`  Already signed in as ${existing.email}`));
+    console.log(import_chalk13.default.dim("  Run ") + import_chalk13.default.cyan("qp logout") + import_chalk13.default.dim(" first to switch accounts."));
+    console.log();
+    try {
+      const status = await getStatusCached(existing.email);
+      const tier2 = await getTierByEmail(existing.email);
+      const tierLabel2 = tier2 === "pro" ? import_chalk13.default.green("Pro") : "Free";
+      console.log(`  ${tierLabel2} plan`);
+      for (const line of formatUsageLines(status, tier2)) {
+        console.log(import_chalk13.default.dim(`  ${line}`));
+      }
+    } catch {
+    }
+    console.log();
+    return;
   }
-  console.log();
-  console.log(import_chalk9.default.yellow.bold("OPTIONS"));
-  for (const [colored, plain, d] of options) {
-    console.log(`  ${pad2(colored, plain, W)}${desc(d)}`);
+  console.log(import_chalk13.default.white("  Sign in with your Google account to track usage"));
+  console.log(import_chalk13.default.white("  and unlock Pro features."));
+  const email = await browserLogin();
+  if (!email) {
+    console.log();
+    console.log(import_chalk13.default.yellow("  Sign-in cancelled or timed out."));
+    console.log(import_chalk13.default.dim("  Run ") + import_chalk13.default.cyan("qp login") + import_chalk13.default.dim(" to try again."));
+    console.log();
+    return;
   }
-  console.log();
-  console.log(import_chalk9.default.yellow.bold("EXAMPLES"));
-  for (const e of examples) {
-    console.log(`  ${e}`);
+  let tier = "free";
+  try {
+    tier = await getTierByEmail(email);
+  } catch {
   }
+  await saveUserData({ email, verified: true, tier });
+  console.log();
+  const tierLabel = tier === "pro" ? import_chalk13.default.green("Pro") : "Free";
+  console.log(import_chalk13.default.green(`  \u2713 Signed in as ${email}`));
+  console.log(`  ${tierLabel} plan`);
+  console.log();
+}
+async function logoutCommand() {
   console.log();
-  console.log(import_chalk9.default.yellow.bold("ENVIRONMENT"));
-  console.log(`  ${pad2(opt("SPARK_API_KEY"), "SPARK_API_KEY", W)}${desc("Spark AI API key")} ${ex("(get at sparkbrain.app/dashboard)")}`);
+  const userData = await loadUserData();
+  if (!userData.email) {
+    console.log(import_chalk13.default.dim("  Not signed in."));
+    console.log();
+    return;
+  }
+  const email = userData.email;
+  await saveUserData({ email: "", verified: false, tier: "free" });
+  console.log(import_chalk13.default.green(`  \u2713 Signed out (${email})`));
   console.log();
 }
 
 // src/commands/record-cmd.ts
+var import_node_fs17 = require("fs");
+var import_promises17 = require("fs/promises");
+var import_node_path24 = require("path");
+var import_chalk18 = __toESM(require("chalk"));
 init_lib();
 
 // src/commands/phases/auth-phase.ts
-var import_chalk11 = __toESM(require("chalk"));
+var import_chalk15 = __toESM(require("chalk"));
 init_lib();
 
 // src/commands/utils/auth-helpers.ts
-var import_chalk10 = __toESM(require("chalk"));
+var import_chalk14 = __toESM(require("chalk"));
 init_lib();
 async function handleRegistrationGate() {
   console.log();
-  console.log(import_chalk10.default.yellow("  \u{1F389} You've made 5 free videos!"));
-  console.log(import_chalk10.default.white("     Register to continue creating videos."));
-  console.log();
-  console.log(import_chalk10.default.dim("  Benefits of registering:"));
-  console.log(import_chalk10.default.dim("    \u2022 20 more videos per month"));
-  console.log(import_chalk10.default.dim("    \u2022 Keep your video history"));
-  console.log(import_chalk10.default.dim("    \u2022 Upgrade to Pro anytime"));
+  console.log(import_chalk14.default.yellow("  \u{1F389} You've made 5 free videos!"));
+  console.log(import_chalk14.default.white("     Sign in to continue creating videos."));
   console.log();
-  const email = await promptInput("Email: ");
+  console.log(import_chalk14.default.dim("  Benefits of signing in:"));
+  console.log(import_chalk14.default.dim("    \u2022 20 more videos per month"));
+  console.log(import_chalk14.default.dim("    \u2022 Keep your video history"));
+  console.log(import_chalk14.default.dim("    \u2022 Upgrade to Pro anytime"));
+  let email = await browserLogin();
+  if (!email) {
+    console.log();
+    email = await promptInput("Email: ");
+  }
   if (!email || !email.includes("@")) {
-    console.log(import_chalk10.default.red("  Invalid email. Run qp again to try again."));
+    console.log(import_chalk14.default.red("  Invalid email. Run qp again to try again."));
     return null;
   }
   const registerTask = task("Sending verification email");
@@ -5117,23 +5502,23 @@ async function handleRegistrationGate() {
   }
   registerTask.succeed("Check your email!");
   console.log();
-  console.log(import_chalk10.default.cyan("  \u{1F4E7} Verification email sent to:"));
-  console.log(import_chalk10.default.white(`     ${email}`));
+  console.log(import_chalk14.default.cyan("  \u{1F4E7} Verification email sent to:"));
+  console.log(import_chalk14.default.white(`     ${email}`));
   console.log();
-  console.log(import_chalk10.default.dim("  Click the link in the email, then press Enter to continue..."));
+  console.log(import_chalk14.default.dim("  Click the link in the email, then press Enter to continue..."));
   await promptInput("");
   const verifyTask = task("Checking verification");
-  const status = await checkVerificationStatus(email);
-  if (status.verified) {
+  const verified = await isVerified(email);
+  if (verified) {
     verifyTask.succeed("Email verified!");
     return { email, verified: true };
   }
   verifyTask.fail("Not verified yet");
   console.log();
-  console.log(import_chalk10.default.yellow("  Email not verified. Check your inbox and spam folder."));
-  console.log(import_chalk10.default.dim("  Run qp again after clicking the verification link."));
+  console.log(import_chalk14.default.yellow("  Email not verified. Check your inbox and spam folder."));
+  console.log(import_chalk14.default.dim("  Run qp again after clicking the verification link."));
   console.log();
-  console.log(import_chalk10.default.cyan(`  Or register/upgrade at: ${getUpgradeUrl(email)}`));
+  console.log(import_chalk14.default.cyan(`  Or register/upgrade at: ${getUpgradeUrl(email)}`));
   console.log();
   return { email, verified: false };
 }
@@ -5141,27 +5526,27 @@ async function handleRegistrationGate() {
 // src/commands/phases/auth-phase.ts
 async function runAuthPhase(input) {
   let { userEmail, userTier, localVideoCount } = input;
-  const { isVerified } = input;
-  if (userEmail && isVerified) {
+  const { isVerified: isVerified2 } = input;
+  if (userEmail && isVerified2) {
     const tierTask = task("Checking subscription");
-    userTier = await getTier(userEmail);
+    userTier = await getTierByEmail(userEmail);
     tierTask.stop();
-    displayUsageStatus(userEmail, userTier, localVideoCount);
+    await displayUsageStatus(userEmail, userTier, localVideoCount);
     if (userTier !== input.userTier) {
       await saveUserData({ tier: userTier });
     }
-  } else if (userEmail && !isVerified) {
+  } else if (userEmail && !isVerified2) {
     const verifyTask = task("Checking verification");
-    const status = await checkVerificationStatus(userEmail);
-    if (status.verified) {
+    const verified = await isVerified(userEmail);
+    if (verified) {
       verifyTask.stop();
-      await saveUserData({ verified: true, tier: status.tier });
-      userTier = status.tier;
-      displayUsageStatus(userEmail, userTier, localVideoCount);
+      userTier = await getTierByEmail(userEmail);
+      await saveUserData({ verified: true, tier: userTier });
+      await displayUsageStatus(userEmail, userTier, localVideoCount);
     } else {
       verifyTask.fail("Email not verified");
       console.log();
-      console.log(import_chalk11.default.yellow("  Check your inbox for the verification email."));
+      console.log(import_chalk15.default.yellow("  Check your inbox for the verification email."));
       console.log();
       const input2 = await promptInput(`New email or Enter to retry (${userEmail}): `);
       if (input2.toLowerCase() === "exit") {
@@ -5181,29 +5566,29 @@ async function runAuthPhase(input) {
           registerTask.stop();
           userEmail = newEmail;
           await saveUserData({ email: newEmail, verified: true });
-          displayUsageStatus(userEmail, userTier, localVideoCount);
+          await displayUsageStatus(userEmail, userTier, localVideoCount);
         } else {
           registerTask.succeed("Check your email!");
           await saveUserData({ email: newEmail, verified: false });
           console.log();
-          console.log(import_chalk11.default.cyan(`  \u{1F4E7} Verification sent to: ${newEmail}`));
-          console.log(import_chalk11.default.dim("  Click the link in the email, then run qp again."));
+          console.log(import_chalk15.default.cyan(`  \u{1F4E7} Verification sent to: ${newEmail}`));
+          console.log(import_chalk15.default.dim("  Click the link in the email, then run qp again."));
           console.log();
           gracefulExit();
           return null;
         }
       } else {
         const recheckTask = task("Rechecking verification");
-        const recheckStatus = await checkVerificationStatus(userEmail);
-        if (recheckStatus.verified) {
+        const recheckVerified = await isVerified(userEmail);
+        if (recheckVerified) {
           recheckTask.stop();
-          await saveUserData({ verified: true, tier: recheckStatus.tier });
-          userTier = recheckStatus.tier;
-          displayUsageStatus(userEmail, userTier, localVideoCount);
+          userTier = await getTierByEmail(userEmail);
+          await saveUserData({ verified: true, tier: userTier });
+          await displayUsageStatus(userEmail, userTier, localVideoCount);
         } else {
           recheckTask.fail("Still not verified");
           console.log();
-          console.log(import_chalk11.default.cyan(`  Register/upgrade at: ${getUpgradeUrl(userEmail)}`));
+          console.log(import_chalk15.default.cyan(`  Register/upgrade at: ${getUpgradeUrl(userEmail)}`));
           console.log();
           gracefulExit();
           return null;
@@ -5226,28 +5611,34 @@ async function runAuthPhase(input) {
       gracefulExit();
       return null;
     }
-    displayUsageStatus(userEmail, userTier, localVideoCount);
+    await displayUsageStatus(userEmail, userTier, localVideoCount);
   } else {
     const remaining = FREE_VIDEO_LIMIT - localVideoCount;
     console.log();
-    console.log(import_chalk11.default.cyan(`  \u{1F3AC} Video ${localVideoCount + 1}/${FREE_VIDEO_LIMIT} free`));
-    console.log(import_chalk11.default.dim(`     ${remaining - 1} more after this \u2022 Sign up for unlimited`));
+    console.log(import_chalk15.default.cyan(`  \u{1F3AC} Video ${localVideoCount + 1}/${FREE_VIDEO_LIMIT} free`));
+    console.log(import_chalk15.default.dim(`     ${remaining - 1} more after this \u2022 Sign up for unlimited`));
     userEmail = await setupUserEmail();
-    await saveUserData({ email: userEmail, verified: false, localVideoCount });
+    let registeredVerified = false;
+    try {
+      const reg = await registerFreeUser(userEmail);
+      registeredVerified = Boolean(reg.success && reg.alreadyVerified);
+    } catch {
+    }
+    await saveUserData({ email: userEmail, verified: registeredVerified, localVideoCount });
   }
   return {
     userEmail: userEmail ?? "anonymous",
     userTier,
     localVideoCount,
-    isVerified
+    isVerified: isVerified2
   };
 }
 
 // src/commands/phases/plan-phase.ts
-var import_node_fs14 = require("fs");
-var import_promises14 = require("fs/promises");
-var import_node_path21 = require("path");
-var import_chalk12 = __toESM(require("chalk"));
+var import_node_fs15 = require("fs");
+var import_promises15 = require("fs/promises");
+var import_node_path22 = require("path");
+var import_chalk16 = __toESM(require("chalk"));
 
 // src/ai/fix.ts
 init_lib();
@@ -5404,9 +5795,9 @@ async function runPlanPhase(params) {
   const extensionPath = config.browser?.extension;
   let existingPlan = null;
   let existingPlanPath = null;
-  if ((0, import_node_fs14.existsSync)(planPath)) {
+  if ((0, import_node_fs15.existsSync)(planPath)) {
     try {
-      const parsed = JSON.parse(await (0, import_promises14.readFile)(planPath, "utf-8"));
+      const parsed = JSON.parse(await (0, import_promises15.readFile)(planPath, "utf-8"));
       if (parsed.url && parsed.steps?.length > 0) {
         existingPlan = parsed;
         existingPlanPath = planPath;
@@ -5416,12 +5807,12 @@ async function runPlanPhase(params) {
   }
   if (!existingPlan) {
     try {
-      const files = (0, import_node_fs14.readdirSync)(config.output.dir);
-      const planFiles = files.filter((f) => /^plan-[a-z]{2}(-[A-Z]{2})?\.json$/.test(f) && f !== (0, import_node_path21.basename)(planPath));
+      const files = (0, import_node_fs15.readdirSync)(config.output.dir);
+      const planFiles = files.filter((f) => /^plan-[a-z]{2}(-[A-Z]{2})?\.json$/.test(f) && f !== (0, import_node_path22.basename)(planPath));
       for (const file of planFiles) {
-        const filePath = (0, import_node_path21.join)(config.output.dir, file);
+        const filePath = (0, import_node_path22.join)(config.output.dir, file);
         try {
-          const parsed = JSON.parse(await (0, import_promises14.readFile)(filePath, "utf-8"));
+          const parsed = JSON.parse(await (0, import_promises15.readFile)(filePath, "utf-8"));
           if (parsed.url && parsed.steps?.length > 0) {
             existingPlan = parsed;
             existingPlanPath = filePath;
@@ -5433,9 +5824,9 @@ async function runPlanPhase(params) {
     } catch {
     }
   }
-  if (!existingPlan && (0, import_node_fs14.existsSync)(legacyPlanPath)) {
+  if (!existingPlan && (0, import_node_fs15.existsSync)(legacyPlanPath)) {
     try {
-      const parsed = JSON.parse(await (0, import_promises14.readFile)(legacyPlanPath, "utf-8"));
+      const parsed = JSON.parse(await (0, import_promises15.readFile)(legacyPlanPath, "utf-8"));
       if (parsed.url && parsed.steps?.length > 0) {
         existingPlan = parsed;
         existingPlanPath = legacyPlanPath;
@@ -5443,8 +5834,8 @@ async function runPlanPhase(params) {
     } catch {
     }
   }
-  const normalizeUrl3 = (u) => u.replace(/\/+$/, "").toLowerCase();
-  const urlMatches = existingPlan && normalizeUrl3(existingPlan.url) === normalizeUrl3(url);
+  const normalizeUrl4 = (u) => u.replace(/\/+$/, "").toLowerCase();
+  const urlMatches = existingPlan && normalizeUrl4(existingPlan.url) === normalizeUrl4(url);
   let plan;
   const doTranslate = async (failMsg) => {
     const translateTask = task(`Translating to ${targetLang}`);
@@ -5461,23 +5852,23 @@ async function runPlanPhase(params) {
   };
   if (existingPlan && existingPlanPath) {
     console.log();
-    console.log(import_chalk12.default.dim(`  Found existing plan: `) + import_chalk12.default.cyan(formatClickablePath(existingPlanPath)));
-    console.log(import_chalk12.default.dim(`  ${existingPlan.steps.length} steps for ${existingPlan.url}`));
+    console.log(import_chalk16.default.dim(`  Found existing plan: `) + import_chalk16.default.cyan(formatClickablePath(existingPlanPath)));
+    console.log(import_chalk16.default.dim(`  ${existingPlan.steps.length} steps for ${existingPlan.url}`));
     if (!urlMatches) {
-      console.log(import_chalk12.default.yellow(`  \u26A0 Plan URL differs from argument:`));
-      console.log(import_chalk12.default.yellow(`    Plan: ${existingPlan.url}`));
-      console.log(import_chalk12.default.yellow(`    Arg:  ${url}`));
+      console.log(import_chalk16.default.yellow(`  \u26A0 Plan URL differs from argument:`));
+      console.log(import_chalk16.default.yellow(`    Plan: ${existingPlan.url}`));
+      console.log(import_chalk16.default.yellow(`    Arg:  ${url}`));
     }
     const existingLang = existingPlan.lang || "en";
     if (existingLang !== targetLang) {
-      console.log(import_chalk12.default.yellow(`  \u26A0 Plan is in ${existingLang}, config is ${targetLang}`));
+      console.log(import_chalk16.default.yellow(`  \u26A0 Plan is in ${existingLang}, config is ${targetLang}`));
     }
     const reuse = await confirm(`${INDENT6}Use existing plan?`);
     if (reuse) {
       plan = await validateAndFixPlan(existingPlanPath, task, logError, userEmail, userTier);
       if (existingPlanPath !== planPath) {
         await savePlan(plan, planPath);
-        console.log(import_chalk12.default.dim(`  Migrated to: ${formatClickablePath(planPath)}`));
+        console.log(import_chalk16.default.dim(`  Migrated to: ${formatClickablePath(planPath)}`));
       }
       if (existingLang !== targetLang) {
         const translate = await confirm(`${INDENT6}Translate to ${targetLang}?`);
@@ -5512,7 +5903,7 @@ async function runPlanPhase(params) {
             uploadIdx++;
           }
         }
-        console.log(import_chalk12.default.dim(`  Preserved upload paths from previous plan`));
+        console.log(import_chalk16.default.dim(`  Preserved upload paths from previous plan`));
       }
       await savePlan(plan, planPath);
       plan = await validateAndFixPlan(planPath, task, logError, userEmail, userTier);
@@ -5536,8 +5927,8 @@ async function runPlanPhase(params) {
   }
   displayPlanSummary(plan);
   console.log();
-  console.log(import_chalk12.default.dim(`  Plan: ${formatClickablePath(planPath)}`));
-  console.log(import_chalk12.default.dim(`  Enter a prompt to refine, or press Enter to continue.`));
+  console.log(import_chalk16.default.dim(`  Plan: ${formatClickablePath(planPath)}`));
+  console.log(import_chalk16.default.dim(`  Enter a prompt to refine, or press Enter to continue.`));
   const MAX_REFINEMENTS = 10;
   let refinementCount = 0;
   while (true) {
@@ -5555,15 +5946,15 @@ async function runPlanPhase(params) {
       refineTask.succeed("Plan refined");
       displayRateLimitInfo();
       if (plan.steps.length > maxSteps) {
-        console.log(import_chalk12.default.yellow(`  \u26A0 ${plan.steps.length} steps exceeds limit of ${maxSteps}`));
+        console.log(import_chalk16.default.yellow(`  \u26A0 ${plan.steps.length} steps exceeds limit of ${maxSteps}`));
       }
       displayPlanSummary(plan);
       console.log();
-      console.log(import_chalk12.default.dim(`  Plan: ${formatClickablePath(planPath)}`));
+      console.log(import_chalk16.default.dim(`  Plan: ${formatClickablePath(planPath)}`));
       if (refinementCount >= MAX_REFINEMENTS) {
         console.log();
-        console.log(import_chalk12.default.yellow(`  \u26A0 You've refined the plan ${MAX_REFINEMENTS} times.`));
-        console.log(import_chalk12.default.dim(`  Further refinements may incur additional costs.`));
+        console.log(import_chalk16.default.yellow(`  \u26A0 You've refined the plan ${MAX_REFINEMENTS} times.`));
+        console.log(import_chalk16.default.dim(`  Further refinements may incur additional costs.`));
         const continueRefining = await confirm(`${INDENT6}Continue refining?`);
         if (!continueRefining) break;
       }
@@ -5575,12 +5966,12 @@ async function runPlanPhase(params) {
   const planLang = plan.lang || "en";
   if (planLang !== targetLang) {
     let useExistingTranslation = false;
-    if ((0, import_node_fs14.existsSync)(planPath) && existingPlanPath !== planPath) {
+    if ((0, import_node_fs15.existsSync)(planPath) && existingPlanPath !== planPath) {
       try {
-        const translatedPlan = JSON.parse(await (0, import_promises14.readFile)(planPath, "utf-8"));
+        const translatedPlan = JSON.parse(await (0, import_promises15.readFile)(planPath, "utf-8"));
         if (translatedPlan.steps?.length === plan.steps.length && translatedPlan.lang === targetLang) {
           console.log();
-          console.log(import_chalk12.default.dim(`  Found translated plan: ${formatClickablePath(planPath)}`));
+          console.log(import_chalk16.default.dim(`  Found translated plan: ${formatClickablePath(planPath)}`));
           const useTranslated = await confirm(`${INDENT6}Use ${targetLang} translation?`);
           if (useTranslated) {
             plan = translatedPlan;
@@ -5592,7 +5983,7 @@ async function runPlanPhase(params) {
     }
     if (!useExistingTranslation) {
       console.log();
-      console.log(import_chalk12.default.yellow(`  Plan is in ${planLang}, but voice is set to ${targetLang}`));
+      console.log(import_chalk16.default.yellow(`  Plan is in ${planLang}, but voice is set to ${targetLang}`));
       const translate = await confirm(`${INDENT6}Translate captions to ${targetLang}?`);
       if (translate) await doTranslate("Translation failed, using original");
     }
@@ -5601,8 +5992,8 @@ async function runPlanPhase(params) {
 }
 
 // src/commands/phases/validation-phase.ts
-var import_promises15 = require("fs/promises");
-var import_chalk13 = __toESM(require("chalk"));
+var import_promises16 = require("fs/promises");
+var import_chalk17 = __toESM(require("chalk"));
 async function runValidationPhase(params) {
   let { plan } = params;
   const { config, planPath, isExtensionUrl, userEmail, userTier = "free" } = params;
@@ -5653,21 +6044,21 @@ async function runValidationPhase(params) {
     const stepNum = result.stepIndex + 1;
     const step = plan.steps[result.stepIndex];
     console.log();
-    console.log(import_chalk13.default.red(`  \u2717 Step ${stepNum}: ${step.action}`));
+    console.log(import_chalk17.default.red(`  \u2717 Step ${stepNum}: ${step.action}`));
     const caption = step.caption || "";
-    if (caption) console.log(import_chalk13.default.dim(`    Caption: ${caption.slice(0, 50)}${caption.length > 50 ? "..." : ""}`));
-    console.log(import_chalk13.default.dim(`    Target: ${step.target || "none"}`));
-    if (step.value) console.log(import_chalk13.default.dim(`    Value: ${step.value}`));
-    console.log(import_chalk13.default.dim(`    Error: ${result.error}`));
+    if (caption) console.log(import_chalk17.default.dim(`    Caption: ${caption.slice(0, 50)}${caption.length > 50 ? "..." : ""}`));
+    console.log(import_chalk17.default.dim(`    Target: ${step.target || "none"}`));
+    if (step.value) console.log(import_chalk17.default.dim(`    Value: ${step.value}`));
+    console.log(import_chalk17.default.dim(`    Error: ${result.error}`));
     if (result.suggestion) {
-      console.log(import_chalk13.default.yellow(`    Hint: ${result.suggestion}`));
+      console.log(import_chalk17.default.yellow(`    Hint: ${result.suggestion}`));
     }
     console.log();
     const isUploadMissingFile = step.action === "upload" && (!step.value || step.value.startsWith("[") || step.value.includes("example") || step.value.includes("/path/to"));
     if (isUploadMissingFile) {
       const filePath = await promptInput('Enter file path to upload (or "skip"): ');
       if (filePath.toLowerCase() === "skip") {
-        console.log(import_chalk13.default.yellow(`  Skipping step ${stepNum}`));
+        console.log(import_chalk17.default.yellow(`  Skipping step ${stepNum}`));
         continue;
       }
       if (filePath) {
@@ -5676,13 +6067,13 @@ async function runValidationPhase(params) {
         const revalidation2 = await validateStepsOnPage(plan, config, logError, config.output.dir);
         const newResult2 = revalidation2.results[result.stepIndex];
         if (newResult2?.success) {
-          console.log(import_chalk13.default.green(`  \u2713 Step ${stepNum} now passes`));
+          console.log(import_chalk17.default.green(`  \u2713 Step ${stepNum} now passes`));
           validationResult = revalidation2;
           continue;
         }
         result.error = newResult2?.error;
         result.suggestion = newResult2?.suggestion;
-        console.log(import_chalk13.default.red(`  Still failing: ${result.error}`));
+        console.log(import_chalk17.default.red(`  Still failing: ${result.error}`));
       }
     }
     const fixTask = task(`Fixing step ${stepNum} with AI`);
@@ -5704,8 +6095,8 @@ async function runValidationPhase(params) {
       await savePlan(plan, planPath);
       fixTask.succeed("AI suggested a fix");
       const fixedStep = plan.steps[result.stepIndex];
-      console.log(import_chalk13.default.dim(`    New target: ${fixedStep.target || "none"}`));
-      if (fixedStep.value) console.log(import_chalk13.default.dim(`    New value: ${fixedStep.value}`));
+      console.log(import_chalk17.default.dim(`    New target: ${fixedStep.target || "none"}`));
+      if (fixedStep.value) console.log(import_chalk17.default.dim(`    New value: ${fixedStep.value}`));
     } catch {
       fixTask.fail("AI could not fix automatically");
     }
@@ -5721,14 +6112,14 @@ async function runValidationPhase(params) {
     result.error = newResult?.error;
     result.suggestion = newResult?.suggestion;
     console.log();
-    console.log(import_chalk13.default.yellow(`  Edit step ${stepNum} in: `) + import_chalk13.default.cyan(formatClickablePath(planPath)));
+    console.log(import_chalk17.default.yellow(`  Edit step ${stepNum} in: `) + import_chalk17.default.cyan(formatClickablePath(planPath)));
     console.log();
     const choice = await promptInput('Press Enter after editing, or type "skip" to skip this step: ');
     if (choice.toLowerCase() === "skip") {
-      console.log(import_chalk13.default.yellow(`  Skipping step ${stepNum} - may fail during recording`));
+      console.log(import_chalk17.default.yellow(`  Skipping step ${stepNum} - may fail during recording`));
       continue;
     }
-    plan = JSON.parse(await (0, import_promises15.readFile)(planPath, "utf-8"));
+    plan = JSON.parse(await (0, import_promises16.readFile)(planPath, "utf-8"));
     const finalRevalidateTask = task(`Final validation of step ${stepNum}`);
     const finalRevalidation = await validateStepsOnPage(plan, config, logError, config.output.dir);
     const finalResult = finalRevalidation.results[result.stepIndex];
@@ -5752,31 +6143,31 @@ async function runValidationPhase(params) {
 }
 
 // src/commands/utils/chrome-extension.ts
-var import_node_fs15 = require("fs");
-var import_node_os2 = require("os");
-var import_node_path22 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_os3 = require("os");
+var import_node_path23 = require("path");
 function resolveChromeExtension(extensionId) {
   const platform = process.platform;
   const possibleDirs = [];
   const getChromeExtDirs = (userDataPath) => {
     const dirs = [];
     try {
-      const profiles = (0, import_node_fs15.readdirSync)(userDataPath).filter((p) => p === "Default" || p.startsWith("Profile "));
+      const profiles = (0, import_node_fs16.readdirSync)(userDataPath).filter((p) => p === "Default" || p.startsWith("Profile "));
       for (const profile of profiles) {
-        dirs.push((0, import_node_path22.join)(userDataPath, profile, "Extensions"));
+        dirs.push((0, import_node_path23.join)(userDataPath, profile, "Extensions"));
       }
     } catch {
-      dirs.push((0, import_node_path22.join)(userDataPath, "Default", "Extensions"));
+      dirs.push((0, import_node_path23.join)(userDataPath, "Default", "Extensions"));
     }
     return dirs;
   };
   if (platform === "win32") {
-    possibleDirs.push(...getChromeExtDirs((0, import_node_path22.join)((0, import_node_os2.homedir)(), "AppData", "Local", "Google", "Chrome", "User Data")));
+    possibleDirs.push(...getChromeExtDirs((0, import_node_path23.join)((0, import_node_os3.homedir)(), "AppData", "Local", "Google", "Chrome", "User Data")));
   } else if (platform === "darwin") {
-    possibleDirs.push(...getChromeExtDirs((0, import_node_path22.join)((0, import_node_os2.homedir)(), "Library", "Application Support", "Google", "Chrome")));
+    possibleDirs.push(...getChromeExtDirs((0, import_node_path23.join)((0, import_node_os3.homedir)(), "Library", "Application Support", "Google", "Chrome")));
   } else {
     try {
-      const windowsUsers = (0, import_node_fs15.readdirSync)("/mnt/c/Users").filter(
+      const windowsUsers = (0, import_node_fs16.readdirSync)("/mnt/c/Users").filter(
         (u) => !["All Users", "Default", "Default User", "Public", "desktop.ini"].includes(u)
       );
       for (const user of windowsUsers) {
@@ -5784,22 +6175,22 @@ function resolveChromeExtension(extensionId) {
       }
     } catch {
     }
-    possibleDirs.push(...getChromeExtDirs((0, import_node_path22.join)((0, import_node_os2.homedir)(), ".config", "google-chrome")));
+    possibleDirs.push(...getChromeExtDirs((0, import_node_path23.join)((0, import_node_os3.homedir)(), ".config", "google-chrome")));
   }
   for (const chromeExtDir of possibleDirs) {
-    const extDir = (0, import_node_path22.join)(chromeExtDir, extensionId);
-    if (!(0, import_node_fs15.existsSync)(extDir)) continue;
+    const extDir = (0, import_node_path23.join)(chromeExtDir, extensionId);
+    if (!(0, import_node_fs16.existsSync)(extDir)) continue;
     try {
-      const versions = (0, import_node_fs15.readdirSync)(extDir).filter((f) => !f.startsWith("."));
+      const versions = (0, import_node_fs16.readdirSync)(extDir).filter((f) => !f.startsWith("."));
       if (versions.length === 0) continue;
       const latestVersion = versions.sort().pop();
-      const extPath = (0, import_node_path22.join)(extDir, latestVersion);
+      const extPath = (0, import_node_path23.join)(extDir, latestVersion);
       let name = extensionId;
       let popupPath = "popup.html";
-      const manifestPath = (0, import_node_path22.join)(extPath, "manifest.json");
-      if ((0, import_node_fs15.existsSync)(manifestPath)) {
+      const manifestPath = (0, import_node_path23.join)(extPath, "manifest.json");
+      if ((0, import_node_fs16.existsSync)(manifestPath)) {
         try {
-          const manifest = JSON.parse((0, import_node_fs15.readFileSync)(manifestPath, "utf-8"));
+          const manifest = JSON.parse((0, import_node_fs16.readFileSync)(manifestPath, "utf-8"));
           if (manifest.name && !manifest.name.startsWith("__MSG_")) {
             name = manifest.name;
           }
@@ -5819,27 +6210,27 @@ function resolveChromeExtension(extensionId) {
 }
 
 // src/commands/record-cmd.ts
-async function recordCommand(url, langOverride, description, skipVoice, fresh, autoYes2) {
+async function recordCommand(url, options = {}) {
+  const { langOverride, description, skipVoice, fresh, autoYes: autoYes2, rethrow } = options;
   if (autoYes2) setAutoYes(true);
   console.log();
   showLogo();
-  checkCredentials();
   const { config, created: configCreated } = await loadConfig(url, langOverride);
   let chromeExtension = null;
   if (url.startsWith("chrome:")) {
     const extensionId = url.slice(7);
     chromeExtension = resolveChromeExtension(extensionId);
     if (!chromeExtension) {
-      console.log(import_chalk14.default.red(`
+      console.log(import_chalk18.default.red(`
   \u2717 Chrome extension not found: ${extensionId}`));
-      console.log(import_chalk14.default.dim(`    Make sure the extension is installed in Chrome
+      console.log(import_chalk18.default.dim(`    Make sure the extension is installed in Chrome
 `));
       process.exit(1);
     }
     config.browser = { extension: chromeExtension.path };
     url = chromeExtension.popupUrl;
-    console.log(import_chalk14.default.dim(`  Extension: ${chromeExtension.name}`));
-    console.log(import_chalk14.default.dim(`  Path: ${chromeExtension.path}`));
+    console.log(import_chalk18.default.dim(`  Extension: ${chromeExtension.name}`));
+    console.log(import_chalk18.default.dim(`  Path: ${chromeExtension.path}`));
   }
   config.output.dir = chromeExtension ? `./${chromeExtension.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}-demo` : getOutputDirFromUrl(url);
   const userData = await loadUserData();
@@ -5852,20 +6243,20 @@ async function recordCommand(url, langOverride, description, skipVoice, fresh, a
   if (!authResult) return;
   const { userEmail, userTier, localVideoCount } = authResult;
   if (configCreated) {
-    const configPath = (0, import_node_path23.join)(process.cwd(), CONFIG_FILE);
+    const configPath = (0, import_node_path24.join)(process.cwd(), CONFIG_FILE);
     console.log();
-    console.log(import_chalk14.default.green(`  \u2714 Created ${CONFIG_FILE}`));
-    console.log(import_chalk14.default.dim(`    ${configPath}`));
+    console.log(import_chalk18.default.green(`  \u2714 Created ${CONFIG_FILE}`));
+    console.log(import_chalk18.default.dim(`    ${configPath}`));
     console.log();
-    console.log(import_chalk14.default.cyan("  Review the config file to customize:"));
-    console.log(import_chalk14.default.dim("    \u2022 lang: Voice language (en, es, ar, zh...)"));
-    console.log(import_chalk14.default.dim("    \u2022 video: Resolution, quality, effects"));
-    console.log(import_chalk14.default.dim("    \u2022 music: Background music path and volume"));
-    console.log(import_chalk14.default.dim("    \u2022 output: Output directory"));
+    console.log(import_chalk18.default.cyan("  Review the config file to customize:"));
+    console.log(import_chalk18.default.dim("    \u2022 lang: Voice language (en, es, ar, zh...)"));
+    console.log(import_chalk18.default.dim("    \u2022 video: Resolution, quality, effects"));
+    console.log(import_chalk18.default.dim("    \u2022 music: Background music path and volume"));
+    console.log(import_chalk18.default.dim("    \u2022 output: Output directory"));
     console.log();
     const proceed = await confirm(`${INDENT3}Proceed with default settings?`);
     if (!proceed) {
-      console.log(import_chalk14.default.yellow(`
+      console.log(import_chalk18.default.yellow(`
   Edit ${CONFIG_FILE} and run again.
 `));
       process.exit(0);
@@ -5873,17 +6264,17 @@ async function recordCommand(url, langOverride, description, skipVoice, fresh, a
   }
   if (langOverride) config.lang = langOverride;
   if (config.music?.path) {
-    const musicPath = (0, import_node_path23.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path23.resolve)(config.output.dir, config.music.path);
-    if (!(0, import_node_fs16.existsSync)(musicPath)) {
+    const musicPath = (0, import_node_path24.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path24.resolve)(config.output.dir, config.music.path);
+    if (!(0, import_node_fs17.existsSync)(musicPath)) {
       console.log();
-      console.log(import_chalk14.default.yellow(`  \u26A0 Music file not found: ${config.music.path}`));
-      console.log(import_chalk14.default.dim(`    Config: ${(0, import_node_path23.join)(process.cwd(), CONFIG_FILE)}`));
+      console.log(import_chalk18.default.yellow(`  \u26A0 Music file not found: ${config.music.path}`));
+      console.log(import_chalk18.default.dim(`    Config: ${(0, import_node_path24.join)(process.cwd(), CONFIG_FILE)}`));
       console.log();
       const proceed = await confirm(`${INDENT3}Continue without background music?`);
       if (!proceed) {
-        console.log(import_chalk14.default.yellow(`
+        console.log(import_chalk18.default.yellow(`
   Edit music.path in config and run again.`));
-        console.log(import_chalk14.default.dim(`    ${(0, import_node_path23.join)(process.cwd(), CONFIG_FILE)}
+        console.log(import_chalk18.default.dim(`    ${(0, import_node_path24.join)(process.cwd(), CONFIG_FILE)}
 `));
         process.exit(0);
       }
@@ -5893,10 +6284,10 @@ async function recordCommand(url, langOverride, description, skipVoice, fresh, a
   const captions = await loadCaptions();
   const workDir = await prepareWorkDir();
   const targetLang = config.lang || "en";
-  const planPath = (0, import_node_path23.join)(config.output.dir, `plan-${targetLang}.json`);
-  const legacyPlanPath = (0, import_node_path23.join)(config.output.dir, "plan.json");
+  const planPath = (0, import_node_path24.join)(config.output.dir, `plan-${targetLang}.json`);
+  const legacyPlanPath = (0, import_node_path24.join)(config.output.dir, "plan.json");
   const isExtensionUrl = url.startsWith("chrome-extension://");
-  await (0, import_promises16.mkdir)(config.output.dir, { recursive: true });
+  await (0, import_promises17.mkdir)(config.output.dir, { recursive: true });
   await setLogFilePath(config.output.dir);
   try {
     const plan = await runPlanPhase({
@@ -5932,35 +6323,37 @@ async function recordCommand(url, langOverride, description, skipVoice, fresh, a
       await saveUserData({ localVideoCount: newCount });
       const remaining = FREE_VIDEO_LIMIT - newCount;
       if (remaining > 0) {
-        console.log(import_chalk14.default.dim(`  ${remaining} free video${remaining === 1 ? "" : "s"} remaining`));
+        console.log(import_chalk18.default.dim(`  ${remaining} free video${remaining === 1 ? "" : "s"} remaining`));
       }
     }
     console.log();
-    console.log(import_chalk14.default.bold.green("  \u2713 Done!"));
+    console.log(import_chalk18.default.bold.green("  \u2713 Done!"));
     console.log();
-    console.log(import_chalk14.default.cyan(`  ${formatClickablePath(finalPath)}`));
+    console.log(import_chalk18.default.cyan(`  ${formatClickablePath(finalPath)}`));
     console.log();
+    return finalPath;
   } catch (err) {
     await logError("Record Command", err);
+    if (rethrow) throw err;
     console.log();
-    console.log(import_chalk14.default.red(`  Error: ${err instanceof Error ? err.message : "Unknown error"}`));
-    console.log(import_chalk14.default.dim(`  See ${logFilePath} for details`));
+    console.log(import_chalk18.default.red(`  Error: ${err instanceof Error ? err.message : "Unknown error"}`));
+    console.log(import_chalk18.default.dim(`  See ${logFilePath} for details`));
     process.exit(1);
   }
 }
 
 // src/commands/script-cmd.ts
-var import_promises17 = require("fs/promises");
-var import_node_path24 = require("path");
-var import_chalk15 = __toESM(require("chalk"));
+var import_promises18 = require("fs/promises");
+var import_node_path25 = require("path");
+var import_chalk19 = __toESM(require("chalk"));
 init_lib();
 async function scriptCommand(url, scriptPath, lang) {
   const { config, workDir, captions } = await initCommandEnv(url, lang);
   header("Script");
-  const raw = await (0, import_promises17.readFile)(scriptPath, "utf-8");
+  const raw = await (0, import_promises18.readFile)(scriptPath, "utf-8");
   const lines = raw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
   if (lines.length === 0) {
-    console.log(import_chalk15.default.red("  Script file is empty or has no non-comment lines"));
+    console.log(import_chalk19.default.red("  Script file is empty or has no non-comment lines"));
     process.exit(1);
   }
   info(`${lines.length} captions from script`);
@@ -5972,7 +6365,7 @@ async function scriptCommand(url, scriptPath, lang) {
   const planTask = task("Mapping script to UI actions");
   const appTitle = new URL(url).hostname.replace(/^www\./, "");
   const plan = await generatePlanFromScript(lines, url, appTitle, elementsText, lang, logError);
-  const planPath = (0, import_node_path24.join)(config.output.dir, `plan-${lang ?? "en"}.json`);
+  const planPath = (0, import_node_path25.join)(config.output.dir, `plan-${lang ?? "en"}.json`);
   await savePlan(plan, planPath);
   planTask.succeed(`${plan.steps.length} steps planned`);
   header("Voiceover");
@@ -5992,15 +6385,15 @@ async function scriptCommand(url, scriptPath, lang) {
   const assPath = await generateASS(plan, stepAudio, workDir, config, captions);
   const finalPath = await composeAndFinish(videoPath, voiceoverPath, assPath, config, "free");
   console.log();
-  console.log(import_chalk15.default.bold.green("  Done!"));
-  console.log(import_chalk15.default.cyan(`  ${finalPath}`));
+  console.log(import_chalk19.default.bold.green("  Done!"));
+  console.log(import_chalk19.default.cyan(`  ${finalPath}`));
 }
 
 // src/qp.ts
 init_lib();
 import_dotenv.default.config({ path: ".env.local", quiet: true });
 import_dotenv.default.config({ quiet: true });
-function normalizeUrl2(input) {
+function normalizeUrl3(input) {
   if (input.startsWith("chrome-extension://") || input.startsWith("chrome:")) {
     return input;
   }
@@ -6032,6 +6425,22 @@ function parseArgs(args) {
     return { ...base, command: "help" };
   }
   const first = args[0];
+  if (first === "login") {
+    return { ...base, command: "login" };
+  }
+  if (first === "logout") {
+    return { ...base, command: "logout" };
+  }
+  if (first === "auth") {
+    const sub = args[1];
+    if (sub === "list" || sub === void 0) {
+      return { ...base, command: "auth-list" };
+    }
+    if (sub === "clear") {
+      return { ...base, command: "auth-clear", url: args[2] ? normalizeUrl3(args[2]) : void 0 };
+    }
+    return { ...base, command: "auth", url: normalizeUrl3(sub) };
+  }
   if (first === "init") {
     return { ...base, command: "init" };
   }
@@ -6055,7 +6464,7 @@ function parseArgs(args) {
       if (arg2.startsWith("lang=")) {
         lang2 = arg2.slice(5);
       } else if (!arg2.startsWith("-") && !url2 && !arg2.includes("=")) {
-        url2 = normalizeUrl2(arg2);
+        url2 = normalizeUrl3(arg2);
       }
     }
     if (!url2) return { ...base, command: "help" };
@@ -6088,7 +6497,7 @@ function parseArgs(args) {
       if (arg2.endsWith(".js") || arg2.endsWith(".ts") || arg2.startsWith("./") || arg2.startsWith("/")) {
         continue;
       }
-      url = normalizeUrl2(arg2);
+      url = normalizeUrl3(arg2);
     }
   }
   if (!url) {
@@ -6104,7 +6513,27 @@ async function main() {
       console.log(`quickpeek v${VERSION}`);
       break;
     case "help":
-      showHelp();
+      await showHelp();
+      break;
+    case "login":
+      await loginCommand();
+      break;
+    case "logout":
+      await logoutCommand();
+      break;
+    case "auth":
+      if (!parsed.url) {
+        console.log(import_chalk20.default.red("  Missing URL"));
+        console.log(import_chalk20.default.dim("  Run: qp auth <url>"));
+        process.exit(1);
+      }
+      await authCommand(parsed.url);
+      break;
+    case "auth-clear":
+      await authClearCommand(parsed.url);
+      break;
+    case "auth-list":
+      await authListCommand();
       break;
     case "init":
       await initCommand();
@@ -6114,8 +6543,8 @@ async function main() {
       break;
     case "record":
       if (!parsed.url) {
-        console.log(import_chalk16.default.red("  Missing URL"));
-        console.log(import_chalk16.default.dim("  Run: qp --help"));
+        console.log(import_chalk20.default.red("  Missing URL"));
+        console.log(import_chalk20.default.dim("  Run: qp --help"));
         process.exit(1);
       }
       setAutoYes(parsed.yes);
@@ -6124,13 +6553,18 @@ async function main() {
         showLogo();
         await scriptCommand(parsed.url, parsed.scriptPath, parsed.lang);
       } else {
-        await recordCommand(parsed.url, parsed.lang, parsed.description, parsed.skipVoice, parsed.fresh);
+        await recordCommand(parsed.url, {
+          langOverride: parsed.lang,
+          description: parsed.description,
+          skipVoice: parsed.skipVoice,
+          fresh: parsed.fresh
+        });
       }
       break;
     case "capture":
       if (!parsed.url) {
-        console.log(import_chalk16.default.red("  Missing URL"));
-        console.log(import_chalk16.default.dim("  Run: qp --help"));
+        console.log(import_chalk20.default.red("  Missing URL"));
+        console.log(import_chalk20.default.dim("  Run: qp --help"));
         process.exit(1);
       }
       console.log();