/* ===== Silenciar logs da extensao no service worker (toggle: chrome.storage ql_debug_logs=true, ou qlLogs(true)) ===== */
(function () {
  try {
    if (console.__qlSilenced) return;
    var on = false;
    var orig = { log: console.log, info: console.info, debug: console.debug, warn: console.warn };
    var noop = function () {};
    function apply() {
      console.log = on ? orig.log : noop;
      console.info = on ? orig.info : noop;
      console.debug = on ? orig.debug : noop;
      console.warn = on ? orig.warn : noop;
    }
    apply();
    console.__qlSilenced = true;
    try {
      chrome.storage.local.get(["ql_debug_logs"], function (e) {
        on = !!(e && e.ql_debug_logs);
        apply();
      });
    } catch (e) {}
    globalThis.qlLogs = function (v) {
      on = !!v;
      try { chrome.storage.local.set({ ql_debug_logs: on }); } catch (e) {}
      apply();
      return on ? "logs ON" : "logs OFF";
    };
  } catch (e) {}
})();

// Na instalação/atualização: notifica e reinjeta os content scripts UMA vez
// (single refresh, sem loop — onInstalled dispara só uma vez por evento), para
// a Raposa aparecer sem o usuário precisar dar F5. Na primeira instalação,
// abre uma aba do Lovable se não houver nenhuma aberta.
chrome.runtime.onInstalled.addListener((details) => {
  if (details.reason !== 'update' && details.reason !== 'install') return;
  console.log("[Background] onInstalled:", details.reason, "— reinjetando abas Lovable");
  chrome.tabs.query(
    { url: ['https://lovable.dev/*', 'https://*.lovable.dev/*', 'https://*.lovableproject.com/*'] },
    (tabs) => {
      let hadTab = false;
      for (const tab of tabs || []) {
        hadTab = true;
        try {
          chrome.tabs.sendMessage(tab.id, { action: 'extensionUpdated' }).catch(() => {});
        } catch (e) {}
        // Refresh único da aba para reinjetar os content scripts atualizados.
        try { chrome.tabs.reload(tab.id); } catch (e) {}
      }
      // Primeira instalação sem nenhuma aba Lovable: abre uma automaticamente.
      if (details.reason === 'install' && !hadTab) {
        try { chrome.tabs.create({ url: 'https://lovable.dev/' }); } catch (e) {}
      }
    }
  );
});

(console.log("[Background] Lovable3s service worker iniciado"),
  chrome.storage.local.get(["ql_sidebar_mode"], (e) => {
    const t = e.ql_sidebar_mode || !1;
    (chrome.sidePanel
      .setPanelBehavior({ openPanelOnActionClick: t })
      .catch(() => {}),
      console.log("[Background] Sidebar mode:", t));
  }),
  chrome.storage.onChanged.addListener((e, t) => {
    if ("local" === t && e.ql_sidebar_mode) {
      const t = e.ql_sidebar_mode.newValue || !1;
      (chrome.sidePanel
        .setPanelBehavior({ openPanelOnActionClick: t })
        .catch(() => {}),
        console.log("[Background] Sidebar mode updated:", t));
    }
  }),
  chrome.action.onClicked.addListener(async (e) => {
    try {
      if ((await chrome.storage.local.get(["ql_sidebar_mode"])).ql_sidebar_mode)
        return void (await chrome.sidePanel.open({ tabId: e.id }));
      // Modo flutuante: revela o popup flutuante na aba ativa, em QUALQUER página.
      if (!e || !e.id) return;
      try {
        await chrome.tabs.sendMessage(e.id, { action: "ql_show_floating" });
      } catch (err) {
        // Content script ainda não injetado nesta aba: injeta e tenta de novo.
        try {
          await chrome.scripting.insertCSS({
            target: { tabId: e.id },
            files: ["floating.css"],
          });
          await chrome.scripting.executeScript({
            target: { tabId: e.id },
            files: [
              "hwFingerprint.js",
              "content-templates.js",
              "content.js",
            ],
          });
          await chrome.tabs.sendMessage(e.id, { action: "ql_show_floating" });
        } catch (err2) {
          console.warn(
            "[Background] não foi possível abrir o flutuante nesta página:",
            err2 && err2.message,
          );
        }
      }
    } catch (e) {
      console.error("[Background] action.onClicked error:", e);
    }
  }),
  chrome.runtime.onMessage.addListener((e, t, a) => {
    if (e && "ping" === e.action) return (a({ ok: !0, ts: Date.now() }), !1);

    // ===== Abrir página da extensão em aba nova (ex.: Painel do Revendedor) =====
    if (e && "QLN_OPEN_TAB" === e.type && e.url) {
      try { chrome.tabs.create({ url: e.url }); } catch (_) {}
      try { a({ ok: true }); } catch (_) {}
      return false;
    }

    // ===== Fechar sidepanel quando ativar chat nativo =====
    // Desliga abertura por clique no ícone E desabilita o panel para a aba.
    // Persiste até openSidePanel reabilitar (em deactivateNativeChat).
    if (e && "closeSidepanel" === e.action) {
      try {
        chrome.sidePanel
          .setPanelBehavior({ openPanelOnActionClick: false })
          .catch(() => {});
        const tabId = t && t.tab && t.tab.id;
        if (tabId) {
          chrome.sidePanel.setOptions({ tabId, enabled: false });
        } else {
          chrome.sidePanel.setOptions({ enabled: false });
        }
      } catch (_) {}
      return false;
    }

    // ===== MODO PLANO: Roteamento de mensagens entre content.js e sidepanel =====
    // Quando o content.js detecta um plano, notifica o sidepanel
    if (e && "planDetected" === e.action) {
      console.log("[Background] Plano detectado, salvando estado e notificando sidepanel");
      chrome.storage.local.set({ ql_plan_visible: true, ql_plan_ts: e.ts });
      return false;
    }

    // Quando o plano some
    if (e && "planGone" === e.action) {
      console.log("[Background] Plano não está mais visível");
      chrome.storage.local.set({ ql_plan_visible: false });
      return false;
    }

    // Quando o sidepanel solicita aprovação do plano
    if (e && "approvePlanRequest" === e.action) {
      console.log("[Background] Sidepanel solicitou aprovação do plano");
      // Envia mensagem para o content script da aba ativa do Lovable
      (async () => {
        try {
          const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
          let lovableTab = tabs && tabs[0] && /lovable\.dev/.test(tabs[0].url || "") ? tabs[0] : null;

          if (!lovableTab) {
            const allTabs = await chrome.tabs.query({ url: ["https://lovable.dev/*", "https://*.lovable.dev/*"] });
            lovableTab = allTabs && allTabs[0];
          }

          if (!lovableTab || !lovableTab.id) {
            a({ ok: false, error: "Nenhuma aba do Lovable encontrada" });
            return;
          }

          // Envia comando para o content.js capturar o plano e clicar em Skip
          chrome.tabs.sendMessage(lovableTab.id, { action: "approvePlanFromSidepanel" }, (response) => {
            if (chrome.runtime.lastError) {
              a({ ok: false, error: chrome.runtime.lastError.message });
            } else {
              a(response);
            }
          });
        } catch (err) {
          a({ ok: false, error: err.message });
        }
      })();
      return true; // resposta assíncrona
    }
    // ===== FIM MODO PLANO =====

    if (e && "lovableSync" === e.action) {
      const t = {};
      (e.token && (t.lovable_token = e.token),
        e.projectId && (t.lovable_projectId = e.projectId),
        Object.keys(t).length &&
          chrome.storage.local.set(t, () => {
            console.log("[Background] saved:", Object.keys(t).join(", "));
          }));
    }
    if (e && "activateSidebar" === e.action)
      return (
        chrome.storage.local.set({ ql_sidebar_mode: !0 }),
        chrome.sidePanel
          .setPanelBehavior({ openPanelOnActionClick: !0 })
          .catch(() => {}),
        t.tab && t.tab.id
          ? chrome.sidePanel
              .open({ tabId: t.tab.id })
              .then(() => {
                a({ ok: !0 });
              })
              .catch((e) => {
                (console.warn(
                  "[Background] sidePanel.open deferred — user must click extension icon:",
                  e.message,
                ),
                  a({
                    ok: !0,
                    deferred: !0,
                    message:
                      "Clique no ícone da extensão para abrir o painel lateral.",
                  }));
              })
          : a({
              ok: !0,
              deferred: !0,
              message:
                "Clique no ícone da extensão para abrir o painel lateral.",
            }),
        !0
      );
    if (e && "deactivateSidebar" === e.action)
      return (
        chrome.storage.local.set({ ql_sidebar_mode: !1 }),
        chrome.sidePanel
          .setPanelBehavior({ openPanelOnActionClick: !1 })
          .catch(() => {}),
        a({ ok: !0 }),
        !1
      );
    if (e && "openSidePanel" === e.action)
      return (
        (async () => {
          try {
            // Reabilita o panel antes de abrir (foi desativado por closeSidepanel)
            const tabId = t && t.tab && t.tab.id;
            try {
              if (tabId) {
                await chrome.sidePanel.setOptions({
                  tabId,
                  enabled: true,
                  path: "sidepanel.html",
                });
              } else {
                await chrome.sidePanel.setOptions({
                  enabled: true,
                  path: "sidepanel.html",
                });
              }
            } catch (_) {}
            try {
              await chrome.sidePanel.setPanelBehavior({
                openPanelOnActionClick: true,
              });
            } catch (_) {}
            if (!tabId) {
              a({ ok: false, error: "No tab context" });
              return;
            }
            await chrome.sidePanel.open({ tabId });
            a({ ok: true });
          } catch (err) {
            console.warn("[Background] openSidePanel deferred:", err.message);
            a({ ok: false, error: err.message });
          }
        })(),
        true
      );
    if (e && "lovableApiFetch" === e.action)
      return (
        (async () => {
          try {
            let t = null;
            const o = await chrome.tabs.query({
              active: !0,
              currentWindow: !0,
            });
            if (
              o &&
              o[0] &&
              !o[0].discarded &&
              /^https:\/\/([^/]+\.)?lovable\.dev\//.test(o[0].url || "")
            )
              t = o[0];
            else {
              const e = await chrome.tabs.query({
                url: ["https://lovable.dev/*", "https://*.lovable.dev/*"],
              });
              // prefere uma aba NÃO descartada (Chrome adormece abas inativas;
              // executeScript numa aba dormindo dá "Frame with ID 0 was removed")
              t =
                (e && e.find((x) => x && !x.discarded)) ||
                (e && e[0]) ||
                null;
            }
            if (!t || !t.id)
              return void a({
                ok: !1,
                status: 0,
                data: { error: "Abra uma aba do Lovable antes de enviar." },
              });
            // se a aba estiver descartada/adormecida, acorda e espera carregar
            if (t.discarded || t.status === "unloaded") {
              try {
                await chrome.tabs.reload(t.id);
                await new Promise((res) => {
                  let done = !1;
                  const to = setTimeout(() => {
                    done || ((done = !0), res());
                  }, 8000);
                  const li = (id, info) => {
                    if (id === t.id && info.status === "complete" && !done) {
                      ((done = !0),
                        clearTimeout(to),
                        chrome.tabs.onUpdated.removeListener(li),
                        res());
                    }
                  };
                  chrome.tabs.onUpdated.addListener(li);
                });
              } catch (_) {}
            }
            const r = await chrome.storage.local.get(["lovable_token"]),
              s = String((r && r.lovable_token) || "")
                .replace(/^Bearer\s+/i, "")
                .trim(),
              n = Object.assign({}, e.headers || {});
            !s ||
              n.Authorization ||
              n.authorization ||
              (n.Authorization = "Bearer " + s);

            // Tenta executeScript com retry (aba pode estar dormindo)
            let c = null, lastErr = null;
            for (let retry = 0; retry < 2; retry++) {
              try {
                c = await chrome.scripting.executeScript({
                  target: { tabId: t.id, frameIds: [0] },
                  world: "MAIN",
                  func: async (e, t) => {
                    try {
                      const a = await fetch(e, t),
                        o = await a.text();
                      let r;
                      try {
                        r = JSON.parse(o);
                      } catch (e) {
                        r = { raw: o };
                      }
                      return { ok: a.ok, status: a.status, data: r };
                    } catch (e) {
                      return {
                        ok: !1,
                        status: 0,
                        data: {
                          error: (e && e.message) || "fetch failed in page",
                        },
                      };
                    }
                  },
                  args: [
                    e.url,
                    {
                      method: e.method || "POST",
                      headers: n,
                      body: e.body || null,
                      credentials: "include",
                    },
                  ],
                });
                break; // sucesso
              } catch (err) {
                lastErr = err;
                if (retry === 0 && err.message && err.message.includes("Frame with ID 0")) {
                  // Aba descartada, tenta acordar e retry
                  try {
                    await chrome.tabs.reload(t.id);
                    await new Promise(r => setTimeout(r, 1500)); // espera 1.5s pra acordar
                  } catch (_) {}
                } else {
                  break; // erro diferente, não retry
                }
              }
            }

            const i = (c && c[0] && c[0].result) || {
              ok: !1,
              status: 0,
              data: { error: lastErr ? lastErr.message : "sem resposta da página Lovable" },
            };
            a(i);
          } catch (e) {
            (console.error("[Background] lovableApiFetch error:", e),
              a({
                ok: !1,
                status: 0,
                data: { error: e.message || "Falha no executeScript." },
              }));
          }
        })(),
        !0
      );
    if (e && "createLovableProjectInPage" === e.action)
      return (
        (async () => {
          try {
            // Busca uma aba do Lovable aberta
            const tabs = await chrome.tabs.query({
              url: ["https://lovable.dev/*", "https://*.lovable.dev/*"],
            });

            if (!tabs || !tabs[0] || !tabs[0].id) {
              return void a({
                ok: !1,
                error: "Abra o Lovable.dev em uma aba e faça login primeiro.",
              });
            }

            const tabId = tabs[0].id;
            const projectTitle = e.title || "Projeto " + new Date().toLocaleString("pt-BR");
            const passedToken = String(e.token || "").replace(/^Bearer\s+/i, "");

            console.log("[Background] Criando projeto na aba do Lovable:", tabId);

            // 1. Injeta os argumentos na página
            await chrome.scripting.executeScript({
              target: { tabId: tabId },
              world: "MAIN",
              func: (title, token) => {
                window.__createProjectArgs = { title, token };
                window.__createProjectResult = null;
              },
              args: [projectTitle, passedToken],
            });

            // 2. Injeta o script de criação
            await chrome.scripting.executeScript({
              target: { tabId: tabId },
              world: "MAIN",
              files: ["createProjectInPage.js"],
            });

            // 3. Espera o resultado (polling)
            let result = null;
            for (let i = 0; i < 30; i++) {
              await new Promise((r) => setTimeout(r, 500));
              const check = await chrome.scripting.executeScript({
                target: { tabId: tabId },
                world: "MAIN",
                func: () => window.__createProjectResult,
              });
              if (check && check[0] && check[0].result) {
                result = check[0].result;
                break;
              }
            }

            // 4. Limpa variáveis globais
            await chrome.scripting.executeScript({
              target: { tabId: tabId },
              world: "MAIN",
              func: () => {
                window.__createProjectArgs = null;
                window.__createProjectResult = null;
              },
            });

            if (!result) {
              return void a({
                ok: !1,
                error: "Timeout ao criar projeto. Tente novamente.",
              });
            }

            console.log("[Background] Resultado da criação:", result);

            if (result.ok && result.projectId) {
              chrome.storage.local.set({
                lovable_projectId: result.projectId,
              });
            }

            a(result);
          } catch (err) {
            console.error("[Background] createLovableProjectInPage error:", err);
            a({
              ok: !1,
              error: err.message || "Falha ao criar projeto.",
            });
          }
        })(),
        !0
      );
    if (e && "proxyFetch" === e.action)
      return (
        (async () => {
          try {
            console.log("[Background] proxyFetch ->", e.url);
            var t = { method: e.method || "POST", headers: e.headers || {} };
            e.body && (t.body = e.body);
            var o,
              r = await fetch(e.url, t),
              s = await r.text();
            try {
              o = JSON.parse(s);
            } catch (e) {
              o = { raw: s };
            }
            a({ ok: r.ok, status: r.status, data: o });
          } catch (e) {
            (console.error("[Background] proxyFetch error:", e),
              a({
                ok: !1,
                status: 0,
                data: { error: e.message || "Fetch failed in background" },
              }));
          }
        })(),
        !0
      );
    if (e && "lovablePut" === e.action)
      return (
        (async () => {
          try {
            // PUT binário da imagem na signed URL do Lovable (anexo NATIVO).
            // Roda no background para usar o privilégio de host_permissions e
            // evitar o bloqueio de CORS que ocorre no content/sidepanel.
            const bin = atob(e.base64 || ""),
              len = bin.length,
              bytes = new Uint8Array(len);
            for (let i = 0; i < len; i++) bytes[i] = bin.charCodeAt(i);
            // Headers da assinatura GCS (x-goog-content-length-range,
            // x-goog-meta-user_id) fazem parte do SignedHeaders da URL assinada.
            // Precisam ser replicados no PUT, senão o GCS rejeita com
            // SignatureDoesNotMatch (403) e o objeto nunca é gravado.
            const putHeaders = { "Content-Type": e.content_type || "image/png" };
            if (e.headers && typeof e.headers === "object")
              for (const k in e.headers)
                if (e.headers[k] != null) putHeaders[k] = String(e.headers[k]);
            const r = await fetch(e.url, {
              method: "PUT",
              headers: putHeaders,
              body: bytes,
            });
            a({ ok: r.ok, status: r.status });
          } catch (err) {
            (console.error("[Background] lovablePut error:", err),
              a({
                ok: !1,
                status: 0,
                error: (err && err.message) || "PUT falhou no background",
              }));
          }
        })(),
        !0
      );
    if (e && "refreshLovableToken" === e.action)
      return (
        (async () => {
          try {
            // Recaptura um token Lovable FRESCO direto do localStorage da aba
            // Lovable (chave sb-*-auth-token). Resolve o "Invalid token" quando
            // o token salvo expirou (~1h). Salva em lovable_token e retorna.
            let t = null;
            const q = await chrome.tabs.query({
              active: !0,
              currentWindow: !0,
            });
            if (
              q &&
              q[0] &&
              /^https:\/\/([^/]+\.)?lovable\.dev\//.test(q[0].url || "")
            )
              t = q[0];
            else {
              const e = await chrome.tabs.query({
                url: ["https://lovable.dev/*", "https://*.lovable.dev/*"],
              });
              t = (e && e[0]) || null;
            }
            if (!t || !t.id)
              return void a({
                ok: !1,
                token: "",
                error: "Abra uma aba do Lovable (logado) e tente novamente.",
              });
            const c = await chrome.scripting.executeScript({
                target: { tabId: t.id },
                world: "MAIN",
                func: () => {
                  try {
                    for (let e = 0; e < localStorage.length; e++) {
                      const t = localStorage.key(e) || "";
                      if (!/^sb-.*-auth-token$/.test(t)) continue;
                      let a = localStorage.getItem(t);
                      if (!a) continue;
                      // supabase-js novo grava o valor como "base64-<base64(JSON)>".
                      // Decodifica antes do parse; sem prefixo segue normal.
                      if (a.slice(0, 7) === "base64-") {
                        try {
                          a = atob(a.slice(7));
                        } catch (e) {
                          continue;
                        }
                      }
                      let o;
                      try {
                        o = JSON.parse(a);
                      } catch (e) {
                        continue;
                      }
                      let r = "";
                      Array.isArray(o)
                        ? (r = o[0] || "")
                        : o &&
                          "object" == typeof o &&
                          (r =
                            o.access_token ||
                            (o.currentSession &&
                              o.currentSession.access_token) ||
                            "");
                      if (r) return r;
                    }
                  } catch (e) {}
                  return "";
                },
              }),
              s = (c && c[0] && c[0].result) || "";
            if (!s)
              return void a({
                ok: !1,
                token: "",
                error:
                  "Não encontrei sessão Lovable ativa. Faça login no Lovable e abra um projeto.",
              });
            const n = String(s).replace(/^Bearer\s+/i, "").trim();
            await chrome.storage.local.set({ lovable_token: n });
            a({ ok: !0, token: n });
          } catch (e) {
            (console.error("[Background] refreshLovableToken error:", e),
              a({
                ok: !1,
                token: "",
                error: e.message || "Falha ao recapturar o token Lovable.",
              }));
          }
        })(),
        !0
      );
    if (e && "readCookies" === e.action) {
      var o = [
          "lovable-session-id.id",
          "lovable-session-id.custom",
          "lovable-session-id.refresh",
          "lovable-session-id.sig",
        ],
        r = [],
        s = 0;
      return (
        o.forEach(function (e) {
          chrome.cookies.get(
            { url: "https://lovable.dev", name: e },
            function (t) {
              (s++,
                t &&
                  t.value &&
                  3 === t.value.split(".").length &&
                  0 === t.value.indexOf("eyJ") &&
                  r.push({
                    token: t.value,
                    cookieName: e,
                    httpOnly: t.httpOnly,
                  }),
                s === o.length && a({ success: r.length > 0, tokens: r }));
            },
          );
        }),
        !0
      );
    }
    // Baixa o ZIP da extensão. Chamado pelo content script (que não tem acesso
    // a chrome.downloads). Baixa direto da URL pública e força o nome fixo.
    if (e && "downloadExtension" === e.action) {
      try {
        chrome.downloads.download(
          { url: e.url, filename: "extensao3s.zip", saveAs: !0 },
          (id) => {
            chrome.runtime.lastError
              ? a({ ok: !1, error: chrome.runtime.lastError.message })
              : a({ ok: !0, downloadId: id });
          },
        );
      } catch (err) {
        a({ ok: !1, error: (err && err.message) || "download falhou" });
      }
      return !0; // resposta assíncrona
    }
    return e && "downloadProject" === e.action
      ? ((async function () {
          // Fonte de dados: API NATIVA da Lovable (git/files+git/file), não
          // GitHub. Fluxo confirmado — ver GUIA-DOWNLOAD-PROJETO-API-NATIVA.md.
          // CRÍTICO: api.lovable.dev rejeita origin chrome-extension://, então
          // TODO o fetch roda DENTRO da aba (executeScript world:"MAIN"), nunca
          // direto do service worker (era exatamente esse o bug antes).
          try {
            var pid = e.projectId, tok = e.token;
            var tabs = await chrome.tabs.query({
              url: ["https://lovable.dev/*", "https://*.lovable.dev/*"],
            });
            var tab = (tabs && tabs.find((x) => x && !x.discarded)) || (tabs && tabs[0]) || null;
            if (!tab || !tab.id)
              return void a({ success: !1, error: "Abra a aba do projeto no Lovable." });

            var out = await chrome.scripting.executeScript({
              target: { tabId: tab.id, frameIds: [0] },
              world: "MAIN",
              args: [pid, tok],
              func: async (pid, tok) => {
                const API = "https://api.lovable.dev";
                const H = { Authorization: "Bearer " + tok };
                async function getJson(url) {
                  const r = await fetch(url, { headers: H, credentials: "include" });
                  if (!r.ok) throw new Error("HTTP " + r.status + " em " + url);
                  return r.json();
                }
                // Espera + confere se o branch/commit já apareceu pra esta
                // conexão (sincronização inicial é assíncrona no servidor).
                async function waitBranch(wsId, connId, tries, delayMs) {
                  for (let i = 0; i < tries; i++) {
                    const branches = await getJson(`${API}/workspaces/${wsId}/connections/gitsync/${connId}/projects/${pid}/branches`).catch(() => []);
                    const br = (branches || []).find((b) => b.name === "main") || (branches || [])[0];
                    if (br && br.commit && br.commit.sha) return br;
                    if (i < tries - 1) await new Promise((r) => setTimeout(r, delayMs));
                  }
                  return null;
                }

                try {
                  // 1+2: acha workspace/conexão dona deste projeto
                  const wsRes = await getJson(`${API}/user/workspaces`);
                  let workspaceId = null, connectionId = null, br = null;
                  const candidates = [];
                  for (const ws of wsRes.workspaces || []) {
                    const conns = await getJson(`${API}/workspaces/${ws.id}/connections/gitsync`).catch(() => ({ connections: [] }));
                    const list = conns.connections || [];
                    const hit = list.find((c) => (c.synced_projects || []).includes(pid));
                    if (hit) { workspaceId = ws.id; connectionId = hit.id; break; }
                    // guarda TODAS as conexões GitHub já autorizadas na conta —
                    // tenta cada uma (não dá pra saber de antemão qual workspace
                    // é dona deste projeto sem tentar).
                    list.forEach((c) => candidates.push({ wsId: ws.id, connId: c.id }));
                  }

                  if (workspaceId) {
                    // já estava sincronizado — só confirma que o branch existe.
                    br = await waitBranch(workspaceId, connectionId, 5, 2000);
                  } else {
                    // Projeto ainda não está em nenhum synced_projects. Tenta
                    // plugar este projeto em cada conexão GitHub já autorizada
                    // (endpoint confirmado por captura real de tráfego — POST
                    // .../sync, sem body, NÃO exige novo consentimento OAuth,
                    // só linka o projeto ao repo daquele workspace) até achar
                    // a que realmente é dona do projeto.
                    for (const cand of candidates) {
                      const syncUrl = `${API}/workspaces/${cand.wsId}/connections/gitsync/${cand.connId}/projects/${pid}/sync`;
                      const sres = await fetch(syncUrl, { method: "POST", headers: H, credentials: "include" }).catch(() => null);
                      if (!sres || !sres.ok) continue;
                      const gotBr = await waitBranch(cand.wsId, cand.connId, 3, 1500);
                      if (gotBr) { workspaceId = cand.wsId; connectionId = cand.connId; br = gotBr; break; }
                    }
                  }

                  if (!workspaceId)
                    return candidates.length
                      ? { success: false, error: "Projeto conectando ao git ainda — tente baixar de novo em alguns segundos." }
                      : { success: false, error: "Nenhuma conta GitHub conectada ainda. Conecte 1x em Settings → GitHub no Lovable e tente de novo." };
                  if (!br) return { success: false, error: "Projeto conectando ao git ainda — tente baixar de novo em alguns segundos." };
                  const ref = br.commit.sha;

                  // 4: lista de arquivos
                  const filesRes = await getJson(`${API}/projects/${pid}/git/files?ref=${encodeURIComponent(ref)}`);
                  const list = filesRes.files || [];
                  if (!list.length) return { success: false, error: "Lista de arquivos vazia." };

                  // 5: conteúdo de cada arquivo (lotes de 8 em paralelo)
                  const out = [];
                  const CONC = 8;
                  for (let i = 0; i < list.length; i += CONC) {
                    const batch = list.slice(i, i + CONC);
                    await Promise.all(batch.map(async (f) => {
                      try {
                        const r = await fetch(`${API}/projects/${pid}/git/file?path=${encodeURIComponent(f.path)}&ref=${encodeURIComponent(ref)}`, { headers: H, credentials: "include" });
                        if (!r.ok) return;
                        if (f.binary) {
                          const buf = await r.arrayBuffer();
                          const bytes = new Uint8Array(buf);
                          let bin = "";
                          for (let j = 0; j < bytes.length; j++) bin += String.fromCharCode(bytes[j]);
                          out.push({ name: f.path, contents: btoa(bin), binary: true });
                        } else {
                          out.push({ name: f.path, contents: await r.text(), binary: false });
                        }
                      } catch (e) {}
                    }));
                  }
                  return { success: true, files: out };
                } catch (err) {
                  return { success: false, error: (err && err.message) || "Falha no fluxo de download." };
                }
              },
            });
            var result = (out && out[0] && out[0].result) || { success: false, error: "sem resposta da página Lovable" };
            a(result);
          } catch (err) {
            a({ success: !1, error: (err && err.message) || "Download falhou" });
          }
        })(),
        !0)
      : e && "removeWatermarkInPage" === e.action
      ? ((async function () {
          // Mesma lógica do sendViaNativeChat (content.js): digita no composer
          // real via execCommand + clica o botão de enviar real. pageHook.js
          // intercepta o /chat resultante e roteia via fix_error sozinho —
          // não precisa reimplementar nada disso aqui, só disparar o envio.
          try {
            var tabs2 = await chrome.tabs.query({
              url: ["https://lovable.dev/*", "https://*.lovable.dev/*"],
            });
            var tab2 = (tabs2 && tabs2.find((x) => x && !x.discarded)) || (tabs2 && tabs2[0]) || null;
            if (!tab2 || !tab2.id)
              return void a({ success: !1, error: "Abra a aba do projeto no Lovable." });
            var prompt2 =
              "Remova a marca d'água do Lovable. Para isso, adicione no início do arquivo CSS principal do projeto (src/index.css, src/styles.css, src/App.css ou o arquivo CSS global existente) exatamente esta regra CSS, sem alterar mais nada:\n#lovable-badge { display: none !important; }\nNão modifique nenhum outro arquivo, layout, texto ou componente. Apenas insira essa regra no CSS global.";
            var out2 = await chrome.scripting.executeScript({
              target: { tabId: tab2.id, frameIds: [0] },
              args: [prompt2],
              func: async (msg) => {
                const form = document.querySelector("form#chat-input");
                const input = form && form.querySelector('[contenteditable="true"]');
                const sendBtn = document.getElementById("chatinput-send-message-button");
                if (!input || !sendBtn) return { success: false, error: "Chat nativo não encontrado." };
                try {
                  input.focus();
                  document.execCommand("selectAll", false, null);
                  document.execCommand("insertText", false, msg);
                  await new Promise((r) => setTimeout(r, 200));
                  if (sendBtn.disabled) return { success: false, error: "Botão de enviar está desabilitado." };
                  sendBtn.click();
                  return { success: true };
                } catch (err) {
                  return { success: false, error: (err && err.message) || "Falha ao enviar." };
                }
              },
            });
            var result2 = (out2 && out2[0] && out2[0].result) || { success: false, error: "sem resposta da página Lovable" };
            a(result2);
          } catch (err) {
            a({ success: !1, error: (err && err.message) || "Falha ao remover marca d'água." });
          }
        })(),
        !0)
      : void 0;
  }));
