whale-code 6.5.7 → 6.5.9

package/dist/server/handlers/google-ads.js

@@ -0,0 +1,2199 @@
+/**
+ * Google Ads Handler — campaign/ad group/ad/keyword CRUD + publish to Google Ads API v23.
+ *
+ * Mirrors the Meta Ads handler pattern:
+ * - Draft objects stored in Supabase with local UUIDs
+ * - Publish pushes drafts to Google Ads API
+ * - Sync pulls metrics from Google Ads into local DB
+ * - GAQL queries for custom reporting
+ *
+ * Actions:
+ *   create_campaign, list_campaigns, get_campaign, update_campaign, delete_campaign,
+ *   create_ad_group, list_ad_groups, get_ad_group, update_ad_group,
+ *   create_ad, list_ads, get_ad, update_ad,
+ *   create_keyword, list_keywords, update_keyword, delete_keyword,
+ *   publish, sync, search (GAQL), list_accessible_customers,
+ *   keyword_ideas, create_conversion_action, list_conversion_actions,
+ *   create_audience, list_audiences, pause, enable
+ */
+
+import { createLogger } from "../lib/logger.js";
+const log = createLogger("google-ads");
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+const GOOGLE_ADS_API = "v23";
+const GOOGLE_ADS_BASE = `https://googleads.googleapis.com/${GOOGLE_ADS_API}`;
+const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+const DAILY_MUTATION_LIMIT = 10_000; // Google Basic Access limit
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+// ============================================================================
+// CREDENTIALS
+// ============================================================================
+
+async function getIntegration(sb, storeId) {
+  // Use RPC to read platform secrets + per-store data in one call
+  const {
+    data: config,
+    error: rpcErr
+  } = await sb.rpc("get_google_config", {
+    p_store_id: storeId
+  });
+
+  // Fallback to direct table read if RPC not yet deployed
+  const data = rpcErr ? await getIntegrationDirect(sb, storeId) : config;
+  if (!data || data.error) {
+    throw new Error(data?.error || "Google Ads not connected. Go to Settings → Google Ads to link your account.");
+  }
+  const accessToken = data.access_token;
+  const refreshToken = data.refresh_token;
+  const clientId = data.client_id;
+  const clientSecret = data.client_secret;
+  const customerId = data.customer_id;
+  const developerToken = data.developer_token;
+  const status = data.status;
+  if (!accessToken || !customerId) {
+    throw new Error("Google Ads not connected. Go to Settings → Google Ads to link your account.");
+  }
+  if (status === "token_expired") {
+    // Attempt one auto-refresh before giving up
+    if (refreshToken && clientId && clientSecret) {
+      const refreshed = await refreshAccessToken(sb, storeId, refreshToken, clientId, clientSecret);
+      return {
+        accessToken: refreshed,
+        refreshToken,
+        clientId,
+        clientSecret,
+        customerId,
+        loginCustomerId: data.login_customer_id || null,
+        developerToken,
+        tokenExpiresAt: null
+      };
+    }
+    throw new Error("Google Ads token expired. Reconnect in Settings → Google Ads.");
+  }
+  if (status !== "connected") {
+    throw new Error(`Google Ads integration status is '${status}'. Reconnect in Settings → Google Ads.`);
+  }
+
+  // Check token expiry and auto-refresh if needed
+  let finalToken = accessToken;
+  if (data.token_expires_at) {
+    const expiresAt = new Date(data.token_expires_at);
+    const bufferMs = 5 * 60 * 1000; // refresh 5 min before expiry
+    if (expiresAt.getTime() - Date.now() < bufferMs && refreshToken && clientId && clientSecret) {
+      finalToken = await refreshAccessToken(sb, storeId, refreshToken, clientId, clientSecret);
+    }
+  }
+  return {
+    accessToken: finalToken,
+    refreshToken,
+    clientId,
+    clientSecret,
+    customerId,
+    loginCustomerId: data.login_customer_id || null,
+    developerToken,
+    tokenExpiresAt: data.token_expires_at || null
+  };
+}
+
+/** Fallback: direct table read (used if get_google_config RPC not deployed) */
+async function getIntegrationDirect(sb, storeId) {
+  const {
+    data,
+    error
+  } = await sb.from("google_integrations").select("client_id, client_secret_encrypted, developer_token_encrypted, customer_id, login_customer_id, access_token_encrypted, refresh_token_encrypted, token_expires_at, status, measurement_id, ga4_api_secret_encrypted").eq("store_id", storeId).limit(1).single();
+  if (error || !data) return null;
+  return {
+    client_id: data.client_id,
+    client_secret: data.client_secret_encrypted,
+    developer_token: data.developer_token_encrypted,
+    customer_id: data.customer_id,
+    login_customer_id: data.login_customer_id,
+    access_token: data.access_token_encrypted,
+    refresh_token: data.refresh_token_encrypted,
+    token_expires_at: data.token_expires_at,
+    status: data.status
+  };
+}
+async function refreshAccessToken(sb, storeId, refreshToken, clientId, clientSecret) {
+  log.info({
+    storeId
+  }, "refreshing Google Ads access token");
+  const res = await fetch(GOOGLE_TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      client_id: clientId,
+      client_secret: clientSecret,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  if (!res.ok) {
+    const errText = await res.text();
+    log.error({
+      storeId,
+      status: res.status,
+      err: errText
+    }, "token refresh failed");
+
+    // Mark integration as token_expired so UI can prompt reconnect
+    await sb.from("google_integrations").update({
+      status: "token_expired",
+      error: `Token refresh failed (${res.status}): ${errText.slice(0, 200)}`,
+      updated_at: new Date().toISOString()
+    }).eq("store_id", storeId);
+    throw new Error(`Token refresh failed (${res.status}). Reconnect in Settings → Google Ads.`);
+  }
+  const tokenData = await res.json();
+  const newToken = tokenData.access_token;
+  const expiresIn = tokenData.expires_in ?? 3600;
+  const expiresAt = new Date(Date.now() + expiresIn * 1000).toISOString();
+
+  // Persist the new token and ensure status is connected
+  await sb.from("google_integrations").update({
+    access_token_encrypted: newToken,
+    token_expires_at: expiresAt,
+    status: "connected",
+    error: null,
+    updated_at: new Date().toISOString()
+  }).eq("store_id", storeId);
+  log.info({
+    storeId,
+    expiresAt
+  }, "Google Ads token refreshed");
+  return newToken;
+}
+
+// ============================================================================
+// RATE LIMITING — 10,000 mutations/day (Google Basic Access)
+// ============================================================================
+
+async function checkAndIncrementMutationQuota(sb, storeId, operationCount, operation) {
+  const today = new Date().toISOString().slice(0, 10);
+
+  // Upsert today's counter
+  const {
+    data: usage
+  } = await sb.from("google_ads_daily_usage").select("mutation_count").eq("store_id", storeId).eq("usage_date", today).maybeSingle();
+  const currentCount = usage?.mutation_count ?? 0;
+  if (currentCount + operationCount > DAILY_MUTATION_LIMIT) {
+    throw new Error(`Google Ads daily mutation limit reached (${currentCount}/${DAILY_MUTATION_LIMIT}). Resets at midnight UTC.`);
+  }
+  await sb.from("google_ads_daily_usage").upsert({
+    store_id: storeId,
+    usage_date: today,
+    mutation_count: currentCount + operationCount,
+    last_operation: operation,
+    updated_at: new Date().toISOString()
+  }, {
+    onConflict: "store_id,usage_date"
+  });
+}
+
+// ============================================================================
+// GOOGLE ADS API HELPERS
+// ============================================================================
+
+function authHeaders(int) {
+  const h = {
+    "Authorization": `Bearer ${int.accessToken}`,
+    "developer-token": int.developerToken,
+    "Content-Type": "application/json"
+  };
+  if (int.loginCustomerId) {
+    h["login-customer-id"] = int.loginCustomerId;
+  }
+  return h;
+}
+function parseGoogleError(body, status) {
+  try {
+    const parsed = JSON.parse(body);
+    const err = parsed.error;
+    if (err?.details?.length) {
+      const detail = err.details[0];
+      if (detail.errors?.length) {
+        return detail.errors.map(e => `${e.errorCode ? JSON.stringify(e.errorCode) : ""}: ${e.message}`).join("; ");
+      }
+    }
+    return err?.message || body.slice(0, 500);
+  } catch {
+    return body.slice(0, 500);
+  }
+}
+
+/** Execute a GAQL search query. */
+async function gaqlSearch(int, query, customerId) {
+  const cid = customerId || int.customerId;
+  const res = await fetch(`${GOOGLE_ADS_BASE}/customers/${cid}/googleAds:search`, {
+    method: "POST",
+    headers: authHeaders(int),
+    body: JSON.stringify({
+      query
+    })
+  });
+  if (!res.ok) {
+    const errBody = await res.text();
+    throw new Error(`GAQL query failed (${res.status}): ${parseGoogleError(errBody, res.status)}`);
+  }
+  const json = await res.json();
+  return json.results || [];
+}
+
+/** Execute a Google Ads API mutate operation with rate limiting and telemetry. */
+async function mutate(int, resourcePath, operations, sb, storeId) {
+  // Rate limit check (if sb/storeId available)
+  if (sb && storeId) {
+    await checkAndIncrementMutationQuota(sb, storeId, operations.length, `mutate:${resourcePath}`);
+  }
+  const cid = int.customerId;
+  const startMs = Date.now();
+  const res = await fetch(`${GOOGLE_ADS_BASE}/customers/${cid}/${resourcePath}:mutate`, {
+    method: "POST",
+    headers: authHeaders(int),
+    body: JSON.stringify({
+      operations
+    })
+  });
+  const durationMs = Date.now() - startMs;
+  if (!res.ok) {
+    const errBody = await res.text();
+    const errMsg = parseGoogleError(errBody, res.status);
+    log.error({
+      resourcePath,
+      status: res.status,
+      durationMs,
+      storeId,
+      err: errMsg
+    }, "Google Ads mutate failed");
+    throw new Error(`Mutate ${resourcePath} failed (${res.status}): ${errMsg}`);
+  }
+  log.info({
+    resourcePath,
+    ops: operations.length,
+    durationMs,
+    storeId
+  }, "Google Ads mutate succeeded");
+  return await res.json();
+}
+
+/** Unified batch mutate — creates multiple resource types atomically with temporary IDs. */
+async function batchMutate(int, mutateOperations, sb, storeId) {
+  if (sb && storeId) {
+    await checkAndIncrementMutationQuota(sb, storeId, mutateOperations.length, "batchMutate");
+  }
+  const cid = int.customerId;
+  const startMs = Date.now();
+  const res = await fetch(`${GOOGLE_ADS_BASE}/customers/${cid}/googleAds:mutate`, {
+    method: "POST",
+    headers: authHeaders(int),
+    body: JSON.stringify({
+      mutateOperations
+    })
+  });
+  const durationMs = Date.now() - startMs;
+  if (!res.ok) {
+    const errBody = await res.text();
+    const errMsg = parseGoogleError(errBody, res.status);
+    log.error({
+      status: res.status,
+      durationMs,
+      storeId,
+      err: errMsg
+    }, "Google Ads batch mutate failed");
+    throw new Error(`Batch mutate failed (${res.status}): ${errMsg}`);
+  }
+  log.info({
+    ops: mutateOperations.length,
+    durationMs,
+    storeId
+  }, "Google Ads batch mutate succeeded");
+  return await res.json();
+}
+
+/** Download image from URL and return base64 data. Returns null if download fails or exceeds maxBytes. */
+async function downloadAndEncodeImage(url, maxBytes = 5_000_000) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return null;
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (buf.length > maxBytes) {
+      log.warn({
+        url: url.split("/").pop(),
+        size: buf.length
+      }, "Image exceeds size limit, skipping");
+      return null;
+    }
+    return buf.toString("base64");
+  } catch (err) {
+    log.warn({
+      url: url.split("/").pop(),
+      err
+    }, "Failed to download image");
+    return null;
+  }
+}
+
+/** Get a resource by resource name. */
+async function getResource(int, resourceName) {
+  const res = await fetch(`${GOOGLE_ADS_BASE}/${resourceName}`, {
+    method: "GET",
+    headers: authHeaders(int)
+  });
+  if (!res.ok) {
+    const errBody = await res.text();
+    throw new Error(`GET ${resourceName} failed (${res.status}): ${parseGoogleError(errBody, res.status)}`);
+  }
+  return await res.json();
+}
+
+// ============================================================================
+// ID HELPERS
+// ============================================================================
+
+/** Local draft IDs contain non-numeric chars. Google IDs are purely numeric. */
+function isLocalId(id) {
+  if (!id) return true;
+  return /[^0-9]/.test(id);
+}
+
+/** Convert budget in dollars to micros (Google uses micros). */
+function toMicros(dollars) {
+  return Math.round(dollars * 1_000_000);
+}
+
+/** Convert micros to dollars. */
+function fromMicros(micros) {
+  return micros / 1_000_000;
+}
+
+// ============================================================================
+// PUBLISH HELPERS
+// ============================================================================
+
+async function publishCampaignToGoogle(sb, int, storeId, campaignId) {
+  // Fetch the draft campaign
+  const {
+    data: campaign,
+    error
+  } = await sb.from("google_campaigns").select("*").eq("id", campaignId).eq("store_id", storeId).single();
+  if (error || !campaign) throw new Error(`Campaign ${campaignId} not found`);
+
+  // Performance Max uses a dedicated publish path (asset groups, not ad groups)
+  if (campaign.campaign_type === "PERFORMANCE_MAX") {
+    const pmaxResult = await publishPMaxCampaign(sb, int, storeId, campaignId);
+    return {
+      googleCampaignId: pmaxResult.googleCampaignId,
+      resourceName: pmaxResult.resourceName
+    };
+  }
+
+  // Already published?
+  if (campaign.google_campaign_id && !isLocalId(campaign.google_campaign_id)) {
+    return {
+      googleCampaignId: campaign.google_campaign_id,
+      resourceName: `customers/${int.customerId}/campaigns/${campaign.google_campaign_id}`
+    };
+  }
+
+  // Create budget first
+  const budgetOps = [{
+    create: {
+      name: `${campaign.name} Budget`,
+      amountMicros: toMicros(campaign.daily_budget || 10).toString(),
+      deliveryMethod: "STANDARD"
+    }
+  }];
+  const budgetResult = await mutate(int, "campaignBudgets", budgetOps, sb, storeId);
+  const budgetResourceName = budgetResult.results ? budgetResult.results[0]?.resourceName : null;
+  if (!budgetResourceName) throw new Error("Failed to create campaign budget");
+
+  // Build campaign operation
+  const campaignOp = {
+    create: {
+      name: campaign.name,
+      advertisingChannelType: campaign.campaign_type || "SEARCH",
+      status: "PAUSED",
+      campaignBudget: budgetResourceName
+    }
+  };
+
+  // EU political advertising compliance (required in v23+)
+  campaignOp.create.containsEuPoliticalAdvertising = "DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING";
+
+  // Bidding strategy (v23: maximizeClicks → targetSpend)
+  const bidding = campaign.bidding_strategy || "MAXIMIZE_CLICKS";
+  switch (bidding) {
+    case "MAXIMIZE_CLICKS":
+      campaignOp.create.targetSpend = {};
+      break;
+    case "MAXIMIZE_CONVERSIONS":
+      campaignOp.create.maximizeConversions = {};
+      break;
+    case "MAXIMIZE_CONVERSION_VALUE":
+      campaignOp.create.maximizeConversionValue = {};
+      break;
+    case "TARGET_CPA":
+      campaignOp.create.targetCpa = {
+        targetCpaMicros: toMicros(campaign.bidding_target || 10).toString()
+      };
+      break;
+    case "TARGET_ROAS":
+      campaignOp.create.targetRoas = {
+        targetRoas: campaign.bidding_target || 1.0
+      };
+      break;
+    case "MANUAL_CPC":
+      campaignOp.create.manualCpc = {};
+      break;
+    default:
+      campaignOp.create.targetSpend = {};
+  }
+
+  // Start/end dates
+  if (campaign.start_date) {
+    campaignOp.create.startDate = campaign.start_date.slice(0, 10).replace(/-/g, "-");
+  }
+  if (campaign.end_date) {
+    campaignOp.create.endDate = campaign.end_date.slice(0, 10).replace(/-/g, "-");
+  }
+  const result = await mutate(int, "campaigns", [campaignOp], sb, storeId);
+  const results = result.results;
+  const resourceName = results?.[0]?.resourceName;
+  if (!resourceName) throw new Error("Campaign creation returned no resource name");
+  const googleCampaignId = resourceName.split("/").pop();
+
+  // Update local record
+  await sb.from("google_campaigns").update({
+    google_campaign_id: googleCampaignId,
+    google_customer_id: int.customerId,
+    google_status: "PAUSED",
+    status: "PUBLISHED",
+    updated_at: new Date().toISOString()
+  }).eq("id", campaignId);
+  return {
+    googleCampaignId,
+    resourceName
+  };
+}
+async function publishAdGroupToGoogle(sb, int, storeId, adGroupId) {
+  const {
+    data: adGroup,
+    error
+  } = await sb.from("google_ad_groups").select("*").eq("id", adGroupId).eq("store_id", storeId).single();
+  if (error || !adGroup) throw new Error(`Ad group ${adGroupId} not found`);
+  if (adGroup.google_ad_group_id && !isLocalId(adGroup.google_ad_group_id)) {
+    return {
+      googleAdGroupId: adGroup.google_ad_group_id,
+      resourceName: `customers/${int.customerId}/adGroups/${adGroup.google_ad_group_id}`
+    };
+  }
+
+  // Auto-publish parent campaign if needed
+  const {
+    googleCampaignId,
+    resourceName: campaignResource
+  } = await publishCampaignToGoogle(sb, int, storeId, adGroup.google_campaign_id);
+  const adGroupOp = {
+    create: {
+      name: adGroup.name,
+      campaign: campaignResource,
+      type: adGroup.ad_group_type || "SEARCH_STANDARD",
+      status: "ENABLED",
+      ...(adGroup.cpc_bid ? {
+        cpcBidMicros: toMicros(adGroup.cpc_bid).toString()
+      } : {})
+    }
+  };
+  const result = await mutate(int, "adGroups", [adGroupOp], sb, storeId);
+  const results = result.results;
+  const resourceName = results?.[0]?.resourceName;
+  if (!resourceName) throw new Error("Ad group creation returned no resource name");
+  const googleAdGroupId = resourceName.split("/").pop();
+  await sb.from("google_ad_groups").update({
+    google_ad_group_id: googleAdGroupId,
+    google_status: "ENABLED",
+    status: "PUBLISHED",
+    updated_at: new Date().toISOString()
+  }).eq("id", adGroupId);
+  return {
+    googleAdGroupId,
+    resourceName
+  };
+}
+async function publishAdToGoogle(sb, int, storeId, adId) {
+  const {
+    data: ad,
+    error
+  } = await sb.from("google_ads").select("*").eq("id", adId).eq("store_id", storeId).single();
+  if (error || !ad) throw new Error(`Ad ${adId} not found`);
+  if (ad.google_ad_id && !isLocalId(ad.google_ad_id)) {
+    return {
+      googleAdId: ad.google_ad_id
+    };
+  }
+
+  // Auto-publish parent ad group
+  const {
+    resourceName: adGroupResource
+  } = await publishAdGroupToGoogle(sb, int, storeId, ad.ad_group_id);
+
+  // Build ad group ad operation based on ad type
+  const adOp = {
+    create: {
+      adGroup: adGroupResource,
+      status: "PAUSED",
+      ad: buildAdPayload(ad)
+    }
+  };
+  const result = await mutate(int, "adGroupAds", [adOp], sb, storeId);
+  const results = result.results;
+  const resourceName = results?.[0]?.resourceName;
+  if (!resourceName) throw new Error("Ad creation returned no resource name");
+
+  // Resource name format: customers/{cid}/adGroupAds/{agid}~{adId}
+  const googleAdId = resourceName.split("~").pop() || resourceName.split("/").pop();
+  await sb.from("google_ads").update({
+    google_ad_id: googleAdId,
+    google_status: "PAUSED",
+    status: "PUBLISHED",
+    updated_at: new Date().toISOString()
+  }).eq("id", adId);
+  return {
+    googleAdId
+  };
+}
+function buildAdPayload(ad) {
+  const adType = ad.ad_type;
+  if (adType === "RESPONSIVE_SEARCH_AD") {
+    const headlines = (ad.headlines || []).map((text, i) => ({
+      text,
+      pinnedField: i < 3 ? undefined : undefined // no pinning by default
+    }));
+    const descriptions = (ad.descriptions || []).map(text => ({
+      text
+    }));
+    return {
+      responsiveSearchAd: {
+        headlines,
+        descriptions
+      },
+      finalUrls: ad.final_urls || [],
+      ...(ad.path1 ? {
+        path1: ad.path1
+      } : {}),
+      ...(ad.path2 ? {
+        path2: ad.path2
+      } : {})
+    };
+  }
+  if (adType === "RESPONSIVE_DISPLAY_AD") {
+    return {
+      responsiveDisplayAd: {
+        headlines: (ad.headlines || []).map(text => ({
+          text
+        })),
+        longHeadline: {
+          text: ad.headlines?.[0] || ""
+        },
+        descriptions: (ad.descriptions || []).map(text => ({
+          text
+        })),
+        businessName: ad.creative?.business_name || ""
+      },
+      finalUrls: ad.final_urls || []
+    };
+  }
+
+  // Default: responsive search ad
+  return {
+    responsiveSearchAd: {
+      headlines: (ad.headlines || []).map(text => ({
+        text
+      })),
+      descriptions: (ad.descriptions || []).map(text => ({
+        text
+      }))
+    },
+    finalUrls: ad.final_urls || []
+  };
+}
+
+// ============================================================================
+// PERFORMANCE MAX PUBLISH
+// ============================================================================
+
+async function publishPMaxCampaign(sb, int, storeId, campaignId) {
+  const {
+    data: campaign
+  } = await sb.from("google_campaigns").select("*").eq("id", campaignId).eq("store_id", storeId).single();
+  if (!campaign) throw new Error(`Campaign ${campaignId} not found`);
+  if (campaign.google_campaign_id && !isLocalId(campaign.google_campaign_id)) {
+    return {
+      googleCampaignId: campaign.google_campaign_id,
+      resourceName: `customers/${int.customerId}/campaigns/${campaign.google_campaign_id}`,
+      assetGroupId: "",
+      imageAssets: 0
+    };
+  }
+
+  // Get the ad row (holds headlines, descriptions, creative with image URLs)
+  const {
+    data: adGroups
+  } = await sb.from("google_ad_groups").select("id").eq("google_campaign_id", campaignId).eq("store_id", storeId);
+  let ad = null;
+  if (adGroups?.length) {
+    const {
+      data
+    } = await sb.from("google_ads").select("*").eq("ad_group_id", adGroups[0].id).eq("store_id", storeId).limit(1);
+    ad = data?.[0] || null;
+  }
+  const creative = ad?.creative || {};
+  const headlines = ad?.headlines || [];
+  const descriptions = ad?.descriptions || [];
+  const finalUrls = ad?.final_urls || [];
+  const longHeadlines = creative.long_headlines || [];
+  const businessName = (creative.business_name || campaign.name).slice(0, 25);
+  const logoUrls = creative.logo_urls || [];
+  const marketingImages = creative.marketing_images || [];
+  const squareImages = creative.square_marketing_images || [];
+  if (!finalUrls.length) throw new Error("PMax requires at least one final URL");
+  if (headlines.length < 3) throw new Error("PMax requires at least 3 headlines");
+  if (descriptions.length < 2) throw new Error("PMax requires at least 2 descriptions");
+  const cid = int.customerId;
+  let nextTempId = -1;
+  const getTempId = () => nextTempId--;
+
+  // ---- Download images first (they must all be in the atomic batch) ----
+  // Use Supabase image transforms for correct aspect ratios when URLs are from Supabase Storage
+  const toTransformUrl = (url, w, h) => {
+    // Convert /storage/v1/object/public/ → /storage/v1/render/image/public/ with resize params
+    if (url.includes("supabase.co/storage/v1/object/public/")) {
+      return url.replace("/storage/v1/object/public/", `/storage/v1/render/image/public/`) + `?width=${w}&height=${h}&resize=cover`;
+    }
+    return url; // External URLs used as-is
+  };
+  log.info({
+    logos: logoUrls.length,
+    landscape: marketingImages.length,
+    square: squareImages.length
+  }, "Downloading PMax image assets");
+
+  // Download logo (1:1, 1200x1200)
+  let logoB64 = null;
+  for (const url of logoUrls.slice(0, 2)) {
+    logoB64 = await downloadAndEncodeImage(toTransformUrl(url, 1200, 1200));
+    if (logoB64) break;
+  }
+
+  // Download landscape images (1.91:1, 1200x628)
+  const landscapeB64 = [];
+  for (const url of marketingImages.slice(0, 5)) {
+    const b64 = await downloadAndEncodeImage(toTransformUrl(url, 1200, 628));
+    if (b64) landscapeB64.push(b64);
+  }
+
+  // Download square images (1:1, 1200x1200)
+  const squareB64 = [];
+  for (const url of squareImages.slice(0, 5)) {
+    const b64 = await downloadAndEncodeImage(toTransformUrl(url, 1200, 1200));
+    if (b64) squareB64.push(b64);
+  }
+
+  // ---- Build ONE atomic batch (unified googleAds:mutate uses snake_case) ----
+  const ops = [];
+  const agAssetLinks = [];
+  const budgetTempId = getTempId();
+  const campaignTempId = getTempId();
+  const assetGroupTempId = getTempId();
+
+  // Budget (PMax requires explicitly_shared: false)
+  ops.push({
+    campaignBudgetOperation: {
+      create: {
+        resource_name: `customers/${cid}/campaignBudgets/${budgetTempId}`,
+        name: `${campaign.name} Budget`,
+        amount_micros: toMicros(campaign.daily_budget || 10).toString(),
+        delivery_method: "STANDARD",
+        explicitly_shared: false
+      }
+    }
+  });
+
+  // Campaign (note: start_date/end_date not supported on create via unified endpoint)
+  const campaignCreate = {
+    resource_name: `customers/${cid}/campaigns/${campaignTempId}`,
+    name: campaign.name,
+    advertising_channel_type: "PERFORMANCE_MAX",
+    status: "PAUSED",
+    campaign_budget: `customers/${cid}/campaignBudgets/${budgetTempId}`,
+    contains_eu_political_advertising: "DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING"
+  };
+  const bidding = campaign.bidding_strategy || "MAXIMIZE_CONVERSIONS";
+  switch (bidding) {
+    case "MAXIMIZE_CONVERSIONS":
+      campaignCreate.maximize_conversions = {};
+      break;
+    case "MAXIMIZE_CONVERSION_VALUE":
+      campaignCreate.maximize_conversion_value = {};
+      break;
+    case "TARGET_CPA":
+      campaignCreate.target_cpa = {
+        target_cpa_micros: toMicros(campaign.bidding_target || 10).toString()
+      };
+      break;
+    case "TARGET_ROAS":
+      campaignCreate.target_roas = {
+        target_roas: campaign.bidding_target || 1.0
+      };
+      break;
+    default:
+      campaignCreate.maximize_conversions = {};
+  }
+  ops.push({
+    campaignOperation: {
+      create: campaignCreate
+    }
+  });
+
+  // Business Name → CampaignAsset ONLY (Brand Guidelines requirement)
+  const bnTempId = getTempId();
+  ops.push({
+    assetOperation: {
+      create: {
+        resource_name: `customers/${cid}/assets/${bnTempId}`,
+        type: "TEXT",
+        text_asset: {
+          text: businessName
+        },
+        name: `Business Name: ${businessName}`
+      }
+    }
+  });
+  ops.push({
+    campaignAssetOperation: {
+      create: {
+        campaign: `customers/${cid}/campaigns/${campaignTempId}`,
+        asset: `customers/${cid}/assets/${bnTempId}`,
+        field_type: "BUSINESS_NAME"
+      }
+    }
+  });
+
+  // Logo → CampaignAsset ONLY (Brand Guidelines: logo must be campaign-level, NOT asset group)
+  if (logoB64) {
+    const logoTempId = getTempId();
+    ops.push({
+      assetOperation: {
+        create: {
+          resource_name: `customers/${cid}/assets/${logoTempId}`,
+          type: "IMAGE",
+          image_asset: {
+            data: logoB64
+          },
+          name: "Logo"
+        }
+      }
+    });
+    ops.push({
+      campaignAssetOperation: {
+        create: {
+          campaign: `customers/${cid}/campaigns/${campaignTempId}`,
+          asset: `customers/${cid}/assets/${logoTempId}`,
+          field_type: "LOGO"
+        }
+      }
+    });
+  }
+
+  // Headlines → AssetGroupAsset
+  for (const h of headlines.slice(0, 15)) {
+    const id = getTempId();
+    ops.push({
+      assetOperation: {
+        create: {
+          resource_name: `customers/${cid}/assets/${id}`,
+          type: "TEXT",
+          text_asset: {
+            text: h
+          },
+          name: `Headline: ${h.slice(0, 50)}`
+        }
+      }
+    });
+    agAssetLinks.push({
+      tempId: id,
+      fieldType: "HEADLINE"
+    });
+  }
+
+  // Descriptions → AssetGroupAsset
+  for (const d of descriptions.slice(0, 5)) {
+    const id = getTempId();
+    ops.push({
+      assetOperation: {
+        create: {
+          resource_name: `customers/${cid}/assets/${id}`,
+          type: "TEXT",
+          text_asset: {
+            text: d
+          },
+          name: `Desc: ${d.slice(0, 50)}`
+        }
+      }
+    });
+    agAssetLinks.push({
+      tempId: id,
+      fieldType: "DESCRIPTION"
+    });
+  }
+
+  // Long headlines → AssetGroupAsset
+  for (const lh of longHeadlines.slice(0, 5)) {
+    const id = getTempId();
+    ops.push({
+      assetOperation: {
+        create: {
+          resource_name: `customers/${cid}/assets/${id}`,
+          type: "TEXT",
+          text_asset: {
+            text: lh
+          },
+          name: `Long: ${lh.slice(0, 50)}`
+        }
+      }
+    });
+    agAssetLinks.push({
+      tempId: id,
+      fieldType: "LONG_HEADLINE"
+    });
+  }
+
+  // Landscape images → AssetGroupAsset
+  for (const b64 of landscapeB64) {
+    const id = getTempId();
+    ops.push({
+      assetOperation: {
+        create: {
+          resource_name: `customers/${cid}/assets/${id}`,
+          type: "IMAGE",
+          image_asset: {
+            data: b64
+          },
+          name: "Landscape"
+        }
+      }
+    });
+    agAssetLinks.push({
+      tempId: id,
+      fieldType: "MARKETING_IMAGE"
+    });
+  }
+
+  // Square images → AssetGroupAsset
+  for (const b64 of squareB64) {
+    const id = getTempId();
+    ops.push({
+      assetOperation: {
+        create: {
+          resource_name: `customers/${cid}/assets/${id}`,
+          type: "IMAGE",
+          image_asset: {
+            data: b64
+          },
+          name: "Square"
+        }
+      }
+    });
+    agAssetLinks.push({
+      tempId: id,
+      fieldType: "SQUARE_MARKETING_IMAGE"
+    });
+  }
+
+  // Asset Group
+  ops.push({
+    assetGroupOperation: {
+      create: {
+        resource_name: `customers/${cid}/assetGroups/${assetGroupTempId}`,
+        campaign: `customers/${cid}/campaigns/${campaignTempId}`,
+        name: `${campaign.name} — Asset Group`,
+        final_urls: finalUrls,
+        status: "ENABLED"
+      }
+    }
+  });
+
+  // Link all assets to asset group (text + images, NOT business name/logo)
+  for (const link of agAssetLinks) {
+    ops.push({
+      assetGroupAssetOperation: {
+        create: {
+          asset_group: `customers/${cid}/assetGroups/${assetGroupTempId}`,
+          asset: `customers/${cid}/assets/${link.tempId}`,
+          field_type: link.fieldType
+        }
+      }
+    });
+  }
+  const imageAssetsCreated = landscapeB64.length + squareB64.length + (logoB64 ? 1 : 0);
+  log.info({
+    ops: ops.length,
+    images: imageAssetsCreated,
+    campaignName: campaign.name
+  }, "Publishing PMax (atomic batch)");
+  const result = await batchMutate(int, ops, sb, storeId);
+
+  // Extract real resource names from response (supports both camelCase and snake_case)
+  const responses = result.mutateOperationResponses || result.mutate_operation_responses || [];
+  let campaignResourceName = "";
+  let googleCampaignId = "";
+  let assetGroupResourceName = "";
+  for (const r of responses) {
+    for (const key of ["campaignResult", "campaign_result"]) {
+      const cr = r[key];
+      const rn = cr?.resourceName || cr?.resource_name;
+      if (rn?.includes("/campaigns/")) {
+        campaignResourceName = rn;
+        googleCampaignId = rn.split("/").pop();
+      }
+    }
+    for (const key of ["assetGroupResult", "asset_group_result"]) {
+      const agr = r[key];
+      const rn = agr?.resourceName || agr?.resource_name;
+      if (rn?.includes("/assetGroups/")) {
+        assetGroupResourceName = rn;
+      }
+    }
+  }
+  if (!googleCampaignId) throw new Error("PMax batch mutate returned no campaign resource name");
+  log.info({
+    googleCampaignId,
+    imageAssetsCreated,
+    assetGroupResourceName
+  }, "PMax campaign published");
+
+  // Update local records
+  await sb.from("google_campaigns").update({
+    google_campaign_id: googleCampaignId,
+    google_customer_id: int.customerId,
+    google_status: "PAUSED",
+    status: "PUBLISHED",
+    updated_at: new Date().toISOString()
+  }).eq("id", campaignId);
+  if (adGroups?.length) {
+    for (const ag of adGroups) {
+      await sb.from("google_ad_groups").update({
+        google_status: "PUBLISHED",
+        status: "PUBLISHED",
+        updated_at: new Date().toISOString()
+      }).eq("id", ag.id);
+    }
+  }
+  return {
+    googleCampaignId,
+    resourceName: campaignResourceName,
+    assetGroupId: assetGroupResourceName,
+    imageAssets: imageAssetsCreated
+  };
+}
+async function publishKeywordsToGoogle(sb, int, storeId, adGroupId) {
+  const {
+    data: keywords
+  } = await sb.from("google_keywords").select("*").eq("ad_group_id", adGroupId).eq("store_id", storeId).is("google_criterion_id", null);
+  if (!keywords?.length) return {
+    published: 0
+  };
+
+  // Get the google ad group resource
+  const {
+    data: adGroup
+  } = await sb.from("google_ad_groups").select("google_ad_group_id").eq("id", adGroupId).single();
+  if (!adGroup?.google_ad_group_id || isLocalId(adGroup.google_ad_group_id)) {
+    throw new Error("Ad group must be published before keywords");
+  }
+  const adGroupResource = `customers/${int.customerId}/adGroups/${adGroup.google_ad_group_id}`;
+  const operations = keywords.map(kw => ({
+    create: {
+      adGroup: adGroupResource,
+      status: "ENABLED",
+      keyword: {
+        text: kw.text,
+        matchType: kw.match_type || "BROAD"
+      },
+      ...(kw.cpc_bid ? {
+        cpcBidMicros: toMicros(kw.cpc_bid).toString()
+      } : {})
+    }
+  }));
+  const result = await mutate(int, "adGroupCriteria", operations, sb, storeId);
+  const results = result.results;
+
+  // Update local records with Google criterion IDs
+  for (let i = 0; i < (results?.length || 0); i++) {
+    const resourceName = results[i]?.resourceName;
+    if (resourceName) {
+      const criterionId = resourceName.split("~").pop();
+      await sb.from("google_keywords").update({
+        google_criterion_id: criterionId,
+        google_status: "ENABLED",
+        updated_at: new Date().toISOString()
+      }).eq("id", keywords[i].id);
+    }
+  }
+  return {
+    published: results?.length || 0
+  };
+}
+
+/** Publish a local conversion action to Google Ads API. */
+async function publishConversionAction(sb, int, storeId, conversionActionId) {
+  const {
+    data: ca
+  } = await sb.from("google_conversion_actions").select("*").eq("id", conversionActionId).eq("store_id", storeId).single();
+  if (!ca) throw new Error("Conversion action not found");
+  if (ca.google_conversion_id) {
+    return {
+      message: "Already published",
+      google_conversion_id: ca.google_conversion_id
+    };
+  }
+  const CATEGORY_MAP = {
+    PURCHASE: "PURCHASE",
+    LEAD: "SUBMIT_LEAD_FORM",
+    SIGNUP: "SIGNUP",
+    ADD_TO_CART: "ADD_TO_CART",
+    PAGE_VIEW: "PAGE_VIEW",
+    OTHER: "DEFAULT"
+  };
+  const result = await mutate(int, "conversionActions", [{
+    create: {
+      name: ca.name,
+      category: CATEGORY_MAP[ca.category] || "DEFAULT",
+      type: "WEBPAGE",
+      status: "ENABLED",
+      countingType: ca.counting_type || "ONE_PER_CLICK",
+      attributionModelSettings: {
+        attributionModel: ca.attribution_model || "GOOGLE_LAST_CLICK"
+      },
+      ...(ca.default_value ? {
+        defaultValue: ca.default_value,
+        alwaysUseDefaultValue: ca.always_use_default_value ?? false
+      } : {})
+    }
+  }], sb, storeId);
+  const results = result.results;
+  const resourceName = results?.[0]?.resourceName;
+  const googleId = resourceName?.split("/").pop();
+  if (googleId) {
+    // Fetch the tag snippet for the newly created conversion action
+    let tagSnippet = null;
+    try {
+      const rows = await gaqlSearch(int, `SELECT conversion_action.tag_snippets FROM conversion_action WHERE conversion_action.resource_name = '${resourceName}'`);
+      const snippets = rows[0]?.conversionAction?.tagSnippets;
+      if (snippets?.length) tagSnippet = snippets[0].eventSnippet || null;
+    } catch {/* non-fatal — snippet fetch can fail */}
+    await sb.from("google_conversion_actions").update({
+      google_conversion_id: googleId,
+      google_tag_snippet: tagSnippet,
+      status: "ENABLED",
+      updated_at: new Date().toISOString()
+    }).eq("id", conversionActionId);
+  }
+  return {
+    google_conversion_id: googleId,
+    resourceName
+  };
+}
+
+// ============================================================================
+// SYNC — pull metrics from Google Ads into local DB
+// ============================================================================
+
+async function syncCampaignMetrics(sb, int, storeId, dateRange) {
+  const VALID_DATE_RANGES = ["LAST_7_DAYS", "LAST_14_DAYS", "LAST_30_DAYS", "LAST_90_DAYS", "THIS_MONTH", "LAST_MONTH", "TODAY", "YESTERDAY"];
+  const range = VALID_DATE_RANGES.includes(dateRange || "") ? dateRange : "LAST_30_DAYS";
+  const query = `
+    SELECT
+      campaign.id,
+      campaign.name,
+      campaign.status,
+      campaign.advertising_channel_type,
+      campaign_budget.amount_micros,
+      metrics.impressions,
+      metrics.clicks,
+      metrics.cost_micros,
+      metrics.conversions,
+      metrics.conversions_value,
+      metrics.ctr,
+      metrics.average_cpc
+    FROM campaign
+    WHERE segments.date DURING ${range}
+  `;
+  const rows = await gaqlSearch(int, query);
+  let synced = 0;
+  for (const row of rows) {
+    const c = row.campaign;
+    const m = row.metrics;
+    const b = row.campaignBudget;
+    const googleCampaignId = String(c.id);
+    await sb.from("google_campaigns").upsert({
+      store_id: storeId,
+      google_campaign_id: googleCampaignId,
+      google_customer_id: int.customerId,
+      name: c.name,
+      campaign_type: c.advertisingChannelType,
+      google_status: c.status,
+      daily_budget: b?.amountMicros ? fromMicros(Number(b.amountMicros)) : null,
+      status: "SYNCED",
+      updated_at: new Date().toISOString()
+    }, {
+      onConflict: "store_id,google_campaign_id",
+      ignoreDuplicates: false
+    });
+    synced++;
+  }
+  return {
+    synced
+  };
+}
+
+// ============================================================================
+// MAIN HANDLER
+// ============================================================================
+
+export async function handleGoogleAds(sb, args, storeId) {
+  if (!storeId) return {
+    success: false,
+    error: "store_id required"
+  };
+  const action = args.action;
+  try {
+    switch (action) {
+      // ====================================================================
+      // CAMPAIGNS
+      // ====================================================================
+
+      case "create_campaign":
+        {
+          const name = args.name;
+          if (!name) return {
+            success: false,
+            error: "name required"
+          };
+          const row = {
+            store_id: storeId,
+            name,
+            campaign_type: args.campaign_type || "SEARCH",
+            status: "DRAFT",
+            daily_budget: args.daily_budget ? Number(args.daily_budget) : null,
+            bidding_strategy: args.bidding_strategy || "MAXIMIZE_CLICKS",
+            bidding_target: args.bidding_target ? Number(args.bidding_target) : null,
+            start_date: args.start_date || null,
+            end_date: args.end_date || null
+          };
+          if (args.campaign_id) row.campaign_id = args.campaign_id; // link to local campaigns table
+
+          const {
+            data,
+            error
+          } = await sb.from("google_campaigns").insert(row).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "list_campaigns":
+        {
+          const query = sb.from("google_campaigns").select("*").eq("store_id", storeId).order("created_at", {
+            ascending: false
+          });
+          if (args.status) query.eq("status", args.status);
+          if (args.limit) query.limit(Number(args.limit));
+          const {
+            data,
+            error
+          } = await query;
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "get_campaign":
+        {
+          const id = args.campaign_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "campaign_id required"
+          };
+          const {
+            data,
+            error
+          } = await sb.from("google_campaigns").select("*").eq("id", id).eq("store_id", storeId).single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "update_campaign":
+        {
+          const id = args.campaign_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "campaign_id required"
+          };
+          const updates = {
+            updated_at: new Date().toISOString()
+          };
+          if (args.name) updates.name = args.name;
+          if (args.daily_budget) updates.daily_budget = Number(args.daily_budget);
+          if (args.bidding_strategy) updates.bidding_strategy = args.bidding_strategy;
+          if (args.bidding_target) updates.bidding_target = Number(args.bidding_target);
+          if (args.status) updates.status = args.status;
+          if (args.start_date) updates.start_date = args.start_date;
+          if (args.end_date) updates.end_date = args.end_date;
+          const {
+            data,
+            error
+          } = await sb.from("google_campaigns").update(updates).eq("id", id).eq("store_id", storeId).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+
+          // If published campaign, also update on Google
+          if (data.google_campaign_id && !isLocalId(data.google_campaign_id)) {
+            try {
+              const int = await getIntegration(sb, storeId);
+              const googleUpdates = {
+                resourceName: `customers/${int.customerId}/campaigns/${data.google_campaign_id}`
+              };
+              if (args.name) googleUpdates.name = args.name;
+              if (args.daily_budget) {
+                // Update budget separately
+                const budgetQuery = `SELECT campaign_budget.resource_name FROM campaign WHERE campaign.id = ${data.google_campaign_id} LIMIT 1`;
+                const budgetRows = await gaqlSearch(int, budgetQuery);
+                if (budgetRows.length) {
+                  const budgetResource = budgetRows[0].campaignBudget?.resourceName;
+                  if (budgetResource) {
+                    await mutate(int, "campaignBudgets", [{
+                      update: {
+                        resourceName: budgetResource,
+                        amountMicros: toMicros(Number(args.daily_budget)).toString()
+                      },
+                      updateMask: "amountMicros"
+                    }], sb, storeId);
+                  }
+                }
+              }
+            } catch (e) {
+              // Non-fatal: local update succeeded, Google update failed
+              return {
+                success: true,
+                data: {
+                  ...data,
+                  warning: `Local updated, but Google sync failed: ${e instanceof Error ? e.message : String(e)}`
+                }
+              };
+            }
+          }
+          return {
+            success: true,
+            data
+          };
+        }
+      case "delete_campaign":
+        {
+          const id = args.campaign_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "campaign_id required"
+          };
+
+          // If published, remove from Google
+          const {
+            data: campaign
+          } = await sb.from("google_campaigns").select("google_campaign_id").eq("id", id).eq("store_id", storeId).single();
+          if (campaign?.google_campaign_id && !isLocalId(campaign.google_campaign_id)) {
+            try {
+              const int = await getIntegration(sb, storeId);
+              await mutate(int, "campaigns", [{
+                remove: `customers/${int.customerId}/campaigns/${campaign.google_campaign_id}`
+              }], sb, storeId);
+            } catch {/* best-effort deletion from Google */}
+          }
+          const {
+            error
+          } = await sb.from("google_campaigns").delete().eq("id", id).eq("store_id", storeId);
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data: {
+              deleted: id
+            }
+          };
+        }
+
+      // ====================================================================
+      // AD GROUPS
+      // ====================================================================
+
+      case "create_ad_group":
+        {
+          const name = args.name;
+          const campaignId = args.campaign_id;
+          if (!name) return {
+            success: false,
+            error: "name required"
+          };
+          if (!campaignId) return {
+            success: false,
+            error: "campaign_id required"
+          };
+          const row = {
+            store_id: storeId,
+            google_campaign_id: campaignId,
+            name,
+            ad_group_type: args.ad_group_type || "SEARCH_STANDARD",
+            status: "DRAFT",
+            cpc_bid: args.cpc_bid ? Number(args.cpc_bid) : null,
+            targeting: args.targeting || null
+          };
+          const {
+            data,
+            error
+          } = await sb.from("google_ad_groups").insert(row).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "list_ad_groups":
+        {
+          const query = sb.from("google_ad_groups").select("*").eq("store_id", storeId).order("created_at", {
+            ascending: false
+          });
+          if (args.campaign_id) query.eq("google_campaign_id", args.campaign_id);
+          if (args.limit) query.limit(Number(args.limit));
+          const {
+            data,
+            error
+          } = await query;
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "get_ad_group":
+        {
+          const id = args.ad_group_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "ad_group_id required"
+          };
+          const {
+            data,
+            error
+          } = await sb.from("google_ad_groups").select("*").eq("id", id).eq("store_id", storeId).single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "update_ad_group":
+        {
+          const id = args.ad_group_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "ad_group_id required"
+          };
+          const updates = {
+            updated_at: new Date().toISOString()
+          };
+          if (args.name) updates.name = args.name;
+          if (args.cpc_bid) updates.cpc_bid = Number(args.cpc_bid);
+          if (args.status) updates.status = args.status;
+          if (args.targeting) updates.targeting = args.targeting;
+          const {
+            data,
+            error
+          } = await sb.from("google_ad_groups").update(updates).eq("id", id).eq("store_id", storeId).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+
+      // ====================================================================
+      // ADS
+      // ====================================================================
+
+      case "create_ad":
+        {
+          const adGroupId = args.ad_group_id;
+          if (!adGroupId) return {
+            success: false,
+            error: "ad_group_id required"
+          };
+          const row = {
+            store_id: storeId,
+            ad_group_id: adGroupId,
+            ad_type: args.ad_type || "RESPONSIVE_SEARCH_AD",
+            headlines: args.headlines || [],
+            descriptions: args.descriptions || [],
+            final_urls: args.final_urls || [],
+            path1: args.path1 || null,
+            path2: args.path2 || null,
+            creative: args.creative || null,
+            status: "DRAFT"
+          };
+          const {
+            data,
+            error
+          } = await sb.from("google_ads").insert(row).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "list_ads":
+        {
+          const query = sb.from("google_ads").select("*").eq("store_id", storeId).order("created_at", {
+            ascending: false
+          });
+          if (args.ad_group_id) query.eq("ad_group_id", args.ad_group_id);
+          if (args.limit) query.limit(Number(args.limit));
+          const {
+            data,
+            error
+          } = await query;
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "get_ad":
+        {
+          const id = args.ad_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "ad_id required"
+          };
+          const {
+            data,
+            error
+          } = await sb.from("google_ads").select("*").eq("id", id).eq("store_id", storeId).single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "update_ad":
+        {
+          const id = args.ad_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "ad_id required"
+          };
+          const updates = {
+            updated_at: new Date().toISOString()
+          };
+          if (args.headlines) updates.headlines = args.headlines;
+          if (args.descriptions) updates.descriptions = args.descriptions;
+          if (args.final_urls) updates.final_urls = args.final_urls;
+          if (args.path1 !== undefined) updates.path1 = args.path1;
+          if (args.path2 !== undefined) updates.path2 = args.path2;
+          if (args.status) updates.status = args.status;
+          const {
+            data,
+            error
+          } = await sb.from("google_ads").update(updates).eq("id", id).eq("store_id", storeId).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+
+      // ====================================================================
+      // KEYWORDS
+      // ====================================================================
+
+      case "create_keyword":
+        {
+          const adGroupId = args.ad_group_id;
+          const text = args.text;
+          if (!adGroupId) return {
+            success: false,
+            error: "ad_group_id required"
+          };
+          if (!text) return {
+            success: false,
+            error: "text required"
+          };
+          const row = {
+            store_id: storeId,
+            ad_group_id: adGroupId,
+            text,
+            match_type: args.match_type || "BROAD",
+            cpc_bid: args.cpc_bid ? Number(args.cpc_bid) : null,
+            status: "DRAFT"
+          };
+          const {
+            data,
+            error
+          } = await sb.from("google_keywords").insert(row).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "list_keywords":
+        {
+          const query = sb.from("google_keywords").select("*").eq("store_id", storeId).order("created_at", {
+            ascending: false
+          });
+          if (args.ad_group_id) query.eq("ad_group_id", args.ad_group_id);
+          if (args.limit) query.limit(Number(args.limit));
+          const {
+            data,
+            error
+          } = await query;
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "update_keyword":
+        {
+          const id = args.keyword_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "keyword_id required"
+          };
+          const updates = {
+            updated_at: new Date().toISOString()
+          };
+          if (args.text) updates.text = args.text;
+          if (args.match_type) updates.match_type = args.match_type;
+          if (args.cpc_bid) updates.cpc_bid = Number(args.cpc_bid);
+          if (args.status) updates.status = args.status;
+          const {
+            data,
+            error
+          } = await sb.from("google_keywords").update(updates).eq("id", id).eq("store_id", storeId).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "delete_keyword":
+        {
+          const id = args.keyword_id || args.id;
+          if (!id) return {
+            success: false,
+            error: "keyword_id required"
+          };
+          const {
+            data: kw
+          } = await sb.from("google_keywords").select("google_criterion_id, ad_group_id").eq("id", id).eq("store_id", storeId).single();
+          if (kw?.google_criterion_id) {
+            try {
+              const int = await getIntegration(sb, storeId);
+              const {
+                data: ag
+              } = await sb.from("google_ad_groups").select("google_ad_group_id").eq("id", kw.ad_group_id).eq("store_id", storeId).single();
+              if (ag?.google_ad_group_id) {
+                await mutate(int, "adGroupCriteria", [{
+                  remove: `customers/${int.customerId}/adGroupCriteria/${ag.google_ad_group_id}~${kw.google_criterion_id}`
+                }], sb, storeId);
+              }
+            } catch {/* best-effort */}
+          }
+          const {
+            error
+          } = await sb.from("google_keywords").delete().eq("id", id).eq("store_id", storeId);
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data: {
+              deleted: id
+            }
+          };
+        }
+
+      // ====================================================================
+      // PUBLISH — push drafts to Google Ads
+      // ====================================================================
+
+      case "publish":
+        {
+          const int = await getIntegration(sb, storeId);
+          const type = args.type || "campaign";
+          const id = args.id || args.campaign_id || args.ad_group_id || args.ad_id;
+          if (!id) return {
+            success: false,
+            error: "id required"
+          };
+          switch (type) {
+            case "campaign":
+              {
+                const result = await publishCampaignToGoogle(sb, int, storeId, id);
+                // Also publish keywords for all ad groups in this campaign
+                const {
+                  data: adGroups
+                } = await sb.from("google_ad_groups").select("id").eq("google_campaign_id", id).eq("store_id", storeId);
+                let keywordsPublished = 0;
+                for (const ag of adGroups || []) {
+                  try {
+                    const kResult = await publishKeywordsToGoogle(sb, int, storeId, ag.id);
+                    keywordsPublished += kResult.published;
+                  } catch {/* non-fatal */}
+                }
+                return {
+                  success: true,
+                  data: {
+                    ...result,
+                    keywordsPublished
+                  }
+                };
+              }
+            case "ad_group":
+              {
+                const result = await publishAdGroupToGoogle(sb, int, storeId, id);
+                const kResult = await publishKeywordsToGoogle(sb, int, storeId, id);
+                return {
+                  success: true,
+                  data: {
+                    ...result,
+                    keywordsPublished: kResult.published
+                  }
+                };
+              }
+            case "ad":
+              {
+                const result = await publishAdToGoogle(sb, int, storeId, id);
+                return {
+                  success: true,
+                  data: result
+                };
+              }
+            case "conversion_action":
+              {
+                const result = await publishConversionAction(sb, int, storeId, id);
+                return {
+                  success: true,
+                  data: result
+                };
+              }
+            default:
+              return {
+                success: false,
+                error: `Unknown publish type: ${type}. Use campaign, ad_group, ad, or conversion_action.`
+              };
+          }
+        }
+
+      // ====================================================================
+      // PAUSE / ENABLE — change status on Google
+      // ====================================================================
+
+      case "pause":
+      case "enable":
+        {
+          const int = await getIntegration(sb, storeId);
+          const type = args.type || "campaign";
+          const id = args.id || args.campaign_id || args.ad_group_id;
+          if (!id) return {
+            success: false,
+            error: "id required"
+          };
+          const newStatus = action === "pause" ? "PAUSED" : "ENABLED";
+          if (type === "campaign") {
+            const {
+              data: c
+            } = await sb.from("google_campaigns").select("google_campaign_id").eq("id", id).eq("store_id", storeId).single();
+            if (!c?.google_campaign_id || isLocalId(c.google_campaign_id)) {
+              return {
+                success: false,
+                error: "Campaign not published to Google yet"
+              };
+            }
+            await mutate(int, "campaigns", [{
+              update: {
+                resourceName: `customers/${int.customerId}/campaigns/${c.google_campaign_id}`,
+                status: newStatus
+              },
+              updateMask: "status"
+            }], sb, storeId);
+            await sb.from("google_campaigns").update({
+              google_status: newStatus,
+              updated_at: new Date().toISOString()
+            }).eq("id", id).eq("store_id", storeId);
+            return {
+              success: true,
+              data: {
+                status: newStatus
+              }
+            };
+          }
+          if (type === "ad_group") {
+            const {
+              data: ag
+            } = await sb.from("google_ad_groups").select("google_ad_group_id").eq("id", id).eq("store_id", storeId).single();
+            if (!ag?.google_ad_group_id || isLocalId(ag.google_ad_group_id)) {
+              return {
+                success: false,
+                error: "Ad group not published to Google yet"
+              };
+            }
+            await mutate(int, "adGroups", [{
+              update: {
+                resourceName: `customers/${int.customerId}/adGroups/${ag.google_ad_group_id}`,
+                status: newStatus
+              },
+              updateMask: "status"
+            }], sb, storeId);
+            await sb.from("google_ad_groups").update({
+              google_status: newStatus,
+              updated_at: new Date().toISOString()
+            }).eq("id", id).eq("store_id", storeId);
+            return {
+              success: true,
+              data: {
+                status: newStatus
+              }
+            };
+          }
+          return {
+            success: false,
+            error: `Unknown type: ${type}`
+          };
+        }
+
+      // ====================================================================
+      // SYNC — pull metrics from Google into local DB
+      // ====================================================================
+
+      case "sync":
+        {
+          const int = await getIntegration(sb, storeId);
+          const dateRange = args.date_range || "LAST_30_DAYS";
+          const result = await syncCampaignMetrics(sb, int, storeId, dateRange);
+          return {
+            success: true,
+            data: result
+          };
+        }
+
+      // ====================================================================
+      // SEARCH — raw GAQL queries
+      // ====================================================================
+
+      case "search":
+        {
+          const query = args.query;
+          if (!query) return {
+            success: false,
+            error: "query (GAQL) required"
+          };
+          const int = await getIntegration(sb, storeId);
+          const customerId = args.customer_id || int.customerId;
+          const results = await gaqlSearch(int, query, customerId);
+          return {
+            success: true,
+            data: {
+              results,
+              totalResults: results.length
+            }
+          };
+        }
+
+      // ====================================================================
+      // LIST ACCESSIBLE CUSTOMERS
+      // ====================================================================
+
+      case "list_accessible_customers":
+        {
+          const int = await getIntegration(sb, storeId);
+          const res = await fetch(`${GOOGLE_ADS_BASE}/customers:listAccessibleCustomers`, {
+            method: "GET",
+            headers: authHeaders(int)
+          });
+          if (!res.ok) {
+            const errBody = await res.text();
+            throw new Error(`listAccessibleCustomers failed (${res.status}): ${parseGoogleError(errBody, res.status)}`);
+          }
+          const data = await res.json();
+          return {
+            success: true,
+            data
+          };
+        }
+
+      // ====================================================================
+      // CONVERSION ACTIONS
+      // ====================================================================
+
+      case "create_conversion_action":
+        {
+          const name = args.name;
+          if (!name) return {
+            success: false,
+            error: "name required"
+          };
+          const row = {
+            store_id: storeId,
+            name,
+            category: args.category || "PURCHASE",
+            counting_type: args.counting_type || "ONE_PER_CLICK",
+            attribution_model: args.attribution_model || "GOOGLE_LAST_CLICK",
+            default_value: args.default_value ? Number(args.default_value) : null,
+            status: "DRAFT"
+          };
+          const {
+            data,
+            error
+          } = await sb.from("google_conversion_actions").insert(row).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "list_conversion_actions":
+        {
+          const {
+            data,
+            error
+          } = await sb.from("google_conversion_actions").select("*").eq("store_id", storeId).order("created_at", {
+            ascending: false
+          });
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+
+      // ====================================================================
+      // AUDIENCES
+      // ====================================================================
+
+      case "create_audience":
+        {
+          const name = args.name;
+          if (!name) return {
+            success: false,
+            error: "name required"
+          };
+          const row = {
+            store_id: storeId,
+            name,
+            audience_type: args.audience_type || "CUSTOM",
+            description: args.description || null,
+            status: "DRAFT"
+          };
+          const {
+            data,
+            error
+          } = await sb.from("google_audiences").insert(row).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "list_audiences":
+        {
+          const {
+            data,
+            error
+          } = await sb.from("google_audiences").select("*").eq("store_id", storeId).order("created_at", {
+            ascending: false
+          });
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+
+      // ====================================================================
+      // KEYWORD IDEAS (Keyword Planner)
+      // ====================================================================
+
+      case "keyword_ideas":
+        {
+          const int = await getIntegration(sb, storeId);
+          const keywords = args.keywords;
+          const url = args.url;
+          if (!keywords?.length && !url) {
+            return {
+              success: false,
+              error: "Provide keywords (array) or url for keyword ideas"
+            };
+          }
+          const body = {
+            language: args.language || "languageConstants/1000",
+            // English
+            geoTargetConstants: args.geo_targets || ["geoTargetConstants/2840"],
+            // US
+            keywordPlanNetwork: "GOOGLE_SEARCH"
+          };
+          if (keywords?.length) {
+            body.keywordSeed = {
+              keywords
+            };
+          }
+          if (url) {
+            body.urlSeed = {
+              url
+            };
+          }
+          const res = await fetch(`${GOOGLE_ADS_BASE}/customers/${int.customerId}:generateKeywordIdeas`, {
+            method: "POST",
+            headers: authHeaders(int),
+            body: JSON.stringify(body)
+          });
+          if (!res.ok) {
+            const errBody = await res.text();
+            throw new Error(`Keyword ideas failed (${res.status}): ${parseGoogleError(errBody, res.status)}`);
+          }
+          const data = await res.json();
+          return {
+            success: true,
+            data
+          };
+        }
+
+      // ====================================================================
+      // CREATE FULL — campaign + ad group + ad + keywords in one call
+      // ====================================================================
+
+      case "create_full":
+        {
+          const name = args.name;
+          if (!name) return {
+            success: false,
+            error: "name required"
+          };
+
+          // 1. Create campaign
+          const campaignRow = {
+            store_id: storeId,
+            name,
+            campaign_type: args.campaign_type || "SEARCH",
+            status: "DRAFT",
+            daily_budget: args.daily_budget ? Number(args.daily_budget) : 10,
+            bidding_strategy: args.bidding_strategy || "MAXIMIZE_CLICKS",
+            bidding_target: args.bidding_target ? Number(args.bidding_target) : null,
+            start_date: args.start_date || null,
+            end_date: args.end_date || null
+          };
+          const {
+            data: campaign,
+            error: campErr
+          } = await sb.from("google_campaigns").insert(campaignRow).select().single();
+          if (campErr) return {
+            success: false,
+            error: campErr.message
+          };
+
+          // 2. Create ad group
+          const adGroupRow = {
+            store_id: storeId,
+            google_campaign_id: campaign.id,
+            name: args.ad_group_name || `${name} — Ad Group`,
+            ad_group_type: args.ad_group_type || "SEARCH_STANDARD",
+            status: "DRAFT",
+            cpc_bid: args.cpc_bid ? Number(args.cpc_bid) : null
+          };
+          const {
+            data: adGroup,
+            error: agErr
+          } = await sb.from("google_ad_groups").insert(adGroupRow).select().single();
+          if (agErr) return {
+            success: false,
+            error: agErr.message
+          };
+
+          // 3. Create ad
+          const adRow = {
+            store_id: storeId,
+            ad_group_id: adGroup.id,
+            ad_type: args.ad_type || "RESPONSIVE_SEARCH_AD",
+            headlines: args.headlines || [],
+            descriptions: args.descriptions || [],
+            final_urls: args.final_urls || [],
+            path1: args.path1 || null,
+            path2: args.path2 || null,
+            creative: args.creative || null,
+            status: "DRAFT"
+          };
+          const {
+            data: ad,
+            error: adErr
+          } = await sb.from("google_ads").insert(adRow).select().single();
+          if (adErr) return {
+            success: false,
+            error: adErr.message
+          };
+
+          // 4. Create keywords (if provided)
+          const keywords = args.keywords;
+          let keywordCount = 0;
+          if (keywords?.length) {
+            const kwRows = keywords.map(kw => ({
+              store_id: storeId,
+              ad_group_id: adGroup.id,
+              text: kw.text,
+              match_type: kw.match_type || "BROAD",
+              status: "DRAFT"
+            }));
+            const {
+              error: kwErr
+            } = await sb.from("google_keywords").insert(kwRows);
+            if (kwErr) throw new Error(`Failed to insert keywords: ${kwErr.message}`);
+            keywordCount = kwRows.length;
+          }
+
+          // 5. Auto-publish if requested
+          let published = false;
+          if (args.auto_publish) {
+            try {
+              const int = await getIntegration(sb, storeId);
+              // PMax: publishCampaignToGoogle handles everything (asset group, assets, links)
+              await publishCampaignToGoogle(sb, int, storeId, campaign.id);
+              if (campaignRow.campaign_type !== "PERFORMANCE_MAX") {
+                await publishAdGroupToGoogle(sb, int, storeId, adGroup.id);
+                await publishAdToGoogle(sb, int, storeId, ad.id);
+                await publishKeywordsToGoogle(sb, int, storeId, adGroup.id);
+              }
+              published = true;
+            } catch (pubErr) {
+              return {
+                success: true,
+                data: {
+                  campaign,
+                  adGroup,
+                  ad,
+                  keywordCount,
+                  published: false,
+                  publishError: pubErr instanceof Error ? pubErr.message : String(pubErr)
+                }
+              };
+            }
+          }
+          return {
+            success: true,
+            data: {
+              campaign,
+              adGroup,
+              ad,
+              keywordCount,
+              published
+            }
+          };
+        }
+
+      // ====================================================================
+      // DEFAULT
+      // ====================================================================
+
+      default:
+        return {
+          success: false,
+          error: `Unknown action: ${action}. Valid actions: create_campaign, list_campaigns, get_campaign, update_campaign, delete_campaign, create_ad_group, list_ad_groups, get_ad_group, update_ad_group, create_ad, list_ads, get_ad, update_ad, create_keyword, list_keywords, update_keyword, delete_keyword, publish, pause, enable, sync, search, list_accessible_customers, keyword_ideas, create_conversion_action, list_conversion_actions, create_audience, list_audiences, create_full`
+        };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+//# sourceMappingURL=google-ads.js.map