@buygent/cli 0.3.0

package/dist/extension/background.js

@@ -0,0 +1,1008 @@
+// extension/protocol.ts
+var BUYGENT_PROTOCOL_VERSION = 1;
+var BUYGENT_NATIVE_HOST_NAME = "com.buygent.host";
+var EXTENSION_RUNTIME_STATE_KEY = "buygentRuntimeState";
+var EXTENSION_ORDER_CHECKPOINT_PREFIX = "buygentOrderCheckpoint:";
+var NATIVE_HOST_SOCKET_FILENAME = `${BUYGENT_NATIVE_HOST_NAME}.sock`;
+var createEnvelope = (type, payload, options) => ({
+  protocolVersion: BUYGENT_PROTOCOL_VERSION,
+  type,
+  messageId: options.messageId,
+  ...options.requestId ? { requestId: options.requestId } : {},
+  sentAt: options.sentAt ?? new Date().toISOString(),
+  source: options.source,
+  payload
+});
+var createErrorEnvelope = (payload, options) => createEnvelope("error", payload, options);
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var decodeEnvelope = (raw, options = {}) => {
+  const fallback = {
+    source: options.source ?? "native-host",
+    messageId: options.messageId ?? `protocol_${Date.now()}`,
+    requestId: options.requestId,
+    sentAt: options.sentAt
+  };
+  if (!isRecord(raw)) {
+    return {
+      ok: false,
+      error: createErrorEnvelope({
+        code: "invalid_envelope",
+        message: "Expected a JSON object envelope."
+      }, fallback)
+    };
+  }
+  if (raw.protocolVersion !== BUYGENT_PROTOCOL_VERSION) {
+    return {
+      ok: false,
+      error: createErrorEnvelope({
+        code: "unsupported_protocol_version",
+        message: `Unsupported protocolVersion: ${String(raw.protocolVersion ?? "missing")}`,
+        details: {
+          supportedProtocolVersion: BUYGENT_PROTOCOL_VERSION
+        }
+      }, fallback)
+    };
+  }
+  if (typeof raw.type !== "string" || typeof raw.messageId !== "string" || typeof raw.sentAt !== "string" || typeof raw.source !== "string") {
+    return {
+      ok: false,
+      error: createErrorEnvelope({
+        code: "invalid_envelope",
+        message: "Envelope must include type, messageId, sentAt, and source fields."
+      }, fallback)
+    };
+  }
+  return {
+    ok: true,
+    envelope: raw
+  };
+};
+var TERMINAL_ORDER_STATES = new Set(["aborted", "completed_dry_run"]);
+var isTerminalOrderState = (state) => TERMINAL_ORDER_STATES.has(state);
+var getOrderCheckpointStorageKey = (orderId) => `${EXTENSION_ORDER_CHECKPOINT_PREFIX}${orderId}`;
+
+// extension/order-error.ts
+var isRecord2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var getOrderIdFromErrorEnvelope = (message) => {
+  const details = message.payload.details;
+  if (!isRecord2(details) || typeof details.orderId !== "string") {
+    return;
+  }
+  return details.orderId;
+};
+var isOrderScopedErrorEnvelope = (message) => typeof getOrderIdFromErrorEnvelope(message) === "string" || typeof message.requestId === "string";
+var relayOrderScopedErrorEnvelope = async (message, dependencies) => {
+  if (!isOrderScopedErrorEnvelope(message)) {
+    return false;
+  }
+  await dependencies.ensureNativePort();
+  dependencies.postToNativeHost(message);
+  return true;
+};
+
+// extension/selector-config.ts
+var DEFAULT_SELECTOR_CONFIG_REFRESH_WINDOW_SECONDS = 600;
+var DEFAULT_SELECTOR_CONFIG_TIMEOUT_MS = 3000;
+var SELECTOR_CONFIG_SETTINGS_STORAGE_KEY = "buygentSelectorConfigSettings";
+var SELECTOR_CONFIG_CACHE_META_STORAGE_KEY = "buygentSelectorConfigCacheMeta:coupang";
+var getSelectorConfigCacheStorageKey = (platform, version) => `buygentSelectorConfigCache:${platform}:${version}`;
+var BUNDLED_COUPANG_SELECTOR_CONFIG = {
+  version: "coupang.v2",
+  platform: "coupang",
+  generatedAt: "2026-05-02T00:00:00.000Z",
+  selectors: {
+    loginIndicators: [
+      "a[href*='mycoupang']",
+      ".my-coupang",
+      ".header-my-coupang",
+      "[data-testid='header-my-coupang']"
+    ],
+    loggedOutIndicators: [
+      "a[href*='login.coupang.com']",
+      "a[href*='/login/login.pang']",
+      "button[aria-label*='로그인']"
+    ],
+    productTitle: [
+      "h1.prod-buy-header__title",
+      ".prod-buy-header__title",
+      "h1[class*='title']",
+      "[data-testid='product-title']",
+      "meta[property='og:title']"
+    ],
+    productPrice: [
+      ".total-price strong",
+      ".prod-sale-price .total-price strong",
+      ".price-value",
+      "[class*='price'] strong"
+    ],
+    optionGroup: [
+      {
+        container: "[data-testid='product-option-selector']",
+        items: "button, [role='button'], option",
+        label: "[data-testid='option-label'], .title, label, strong"
+      },
+      {
+        container: ".prod-option",
+        items: "button, [role='button'], option",
+        label: ".title, label, strong"
+      },
+      {
+        container: "select[class*='option'], .prod-option select",
+        items: "option",
+        label: "label, strong, .title"
+      },
+      {
+        container: "select[name*='quantity'], select[id*='quantity']",
+        items: "option",
+        label: "label, strong, .title"
+      }
+    ],
+    buyNowButton: [
+      "button.prod-buy-btn",
+      "button[aria-label*='바로구매']",
+      "[data-testid='buy-now-button']",
+      "[data-cy='buy-now-button']",
+      "[data-automation-id='buy-now-button']"
+    ],
+    addToCartButton: [
+      "button.prod-cart-btn",
+      "button[aria-label*='장바구니']",
+      "[data-testid='add-to-cart-button']",
+      "[data-cy='add-to-cart-button']"
+    ],
+    cartCheckoutButton: [
+      "[data-testid='cart-order-button']",
+      "[data-cy='cart-order-button']",
+      "[data-automation-id='cart-order-button']"
+    ],
+    checkoutTotal: [
+      ".order-sheet .total-price strong",
+      "[data-testid='payment-total'] strong",
+      ".final-payment-price strong",
+      ".price-area strong"
+    ]
+  }
+};
+
+// extension/content/coupang-probe.ts
+var CHECKOUT_URL_PATTERN = /checkout\.coupang\.com|\/order-form|\/payment/u;
+
+// extension/content/order-state.ts
+var chromeApi = globalThis.chrome;
+var storageArea = chromeApi?.storage?.session ?? chromeApi?.storage?.local;
+
+// extension/content/coupang-order.ts
+var COUPANG_CART_URL = "https://cart.coupang.com/cartView.pang";
+
+// extension/order-resume.ts
+var inFlightResumeDispatches = new Map;
+var COUPANG_CHECKOUT_RESUME_STATES = new Set([
+  "cart_added",
+  "checkout_loaded",
+  "awaiting_user_confirm"
+]);
+var toOrderStartPayload = (checkpoint) => ({
+  orderId: checkpoint.orderId,
+  platform: checkpoint.platform,
+  productUrl: checkpoint.productUrl,
+  ...typeof checkpoint.maxPriceKrw === "number" ? { maxPriceKrw: checkpoint.maxPriceKrw } : {},
+  dryRun: true,
+  ...typeof checkpoint.tabId === "number" ? { tabId: checkpoint.tabId } : {}
+});
+var withResumeState = (checkpoint, resumeState) => {
+  if (!resumeState) {
+    const { resumeState: _resumeState, ...rest } = checkpoint;
+    return rest;
+  }
+  return {
+    ...checkpoint,
+    resumeState
+  };
+};
+var isKnownOrderResumeUrl = (checkpoint, url) => {
+  if (url === checkpoint.productUrl) {
+    return true;
+  }
+  if (url === COUPANG_CART_URL) {
+    return true;
+  }
+  if (checkpoint.pageUrl && url === checkpoint.pageUrl) {
+    return true;
+  }
+  return COUPANG_CHECKOUT_RESUME_STATES.has(checkpoint.state) && CHECKOUT_URL_PATTERN.test(url);
+};
+var shouldResumeStoredOrder = (checkpoint, tabId, url) => checkpoint.platform === "coupang" && typeof checkpoint.tabId === "number" && checkpoint.tabId === tabId && !checkpoint.resumeState && !isTerminalOrderState(checkpoint.state) && isKnownOrderResumeUrl(checkpoint, url);
+var dispatchStoredOrderResume = async (options) => {
+  const candidate = options.checkpoints.find((checkpoint) => shouldResumeStoredOrder(checkpoint, options.tabId, options.url));
+  if (!candidate) {
+    return false;
+  }
+  if (inFlightResumeDispatches.has(candidate.orderId)) {
+    return false;
+  }
+  const dispatch = (async () => {
+    const resuming = withResumeState(candidate, "resuming");
+    await options.writeCheckpoint(resuming);
+    try {
+      await options.sendResume(createEnvelope("order:resume", toOrderStartPayload(candidate), {
+        source: "extension:background",
+        messageId: options.createMessageId()
+      }));
+      await options.writeCheckpoint(withResumeState(resuming, "resumed"));
+      return true;
+    } catch (error) {
+      await options.writeCheckpoint(withResumeState(candidate, undefined));
+      throw error;
+    }
+  })();
+  inFlightResumeDispatches.set(candidate.orderId, dispatch);
+  try {
+    return await dispatch;
+  } finally {
+    if (inFlightResumeDispatches.get(candidate.orderId) === dispatch) {
+      inFlightResumeDispatches.delete(candidate.orderId);
+    }
+  }
+};
+
+// extension/selector-config-service.ts
+var isRecord3 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+var isOptionGroupArray = (value) => Array.isArray(value) && value.every((entry) => isRecord3(entry) && typeof entry.container === "string" && typeof entry.items === "string" && (entry.label === undefined || typeof entry.label === "string"));
+var COUPANG_SELECTOR_CONFIG_CACHE_KEY_PREFIX = getSelectorConfigCacheStorageKey("coupang", "");
+var parseStoredValue = (value) => {
+  if (typeof value !== "string") {
+    return value;
+  }
+  return JSON.parse(value);
+};
+var logCacheInvalidationFailure = (keys, error) => {
+  console.warn("Failed to invalidate malformed selector-config cache entries.", {
+    keys,
+    error: error instanceof Error ? error.message : String(error)
+  });
+};
+var invalidateMalformedCacheEntries = async (storage, keys) => {
+  const entries = [...new Set(Array.isArray(keys) ? keys : [keys])];
+  try {
+    await storage.remove(entries.length === 1 ? entries[0] : entries);
+  } catch (error) {
+    logCacheInvalidationFailure(entries, error);
+  }
+};
+var compareRecoveredCachePayloads = (left, right) => {
+  const leftGeneratedAt = Date.parse(left.generatedAt);
+  const rightGeneratedAt = Date.parse(right.generatedAt);
+  const leftHasGeneratedAt = Number.isFinite(leftGeneratedAt);
+  const rightHasGeneratedAt = Number.isFinite(rightGeneratedAt);
+  if (leftHasGeneratedAt && rightHasGeneratedAt && leftGeneratedAt !== rightGeneratedAt) {
+    return leftGeneratedAt - rightGeneratedAt;
+  }
+  if (leftHasGeneratedAt !== rightHasGeneratedAt) {
+    return leftHasGeneratedAt ? 1 : -1;
+  }
+  return left.version.localeCompare(right.version);
+};
+var parseCachedConfigEntry = async (storage, cacheKey, raw) => {
+  let parsed;
+  try {
+    parsed = parseStoredValue(raw);
+  } catch {
+    await invalidateMalformedCacheEntries(storage, cacheKey);
+    return;
+  }
+  const cached = parseCoupangSelectorConfigResponse(parsed);
+  if (!cached) {
+    await invalidateMalformedCacheEntries(storage, cacheKey);
+    return;
+  }
+  return cached;
+};
+var readRecoveredCachedConfig = async (storage, refreshWindowSeconds, resolvedAt, endpoint) => {
+  const stored = await storage.get(null);
+  let recovered;
+  for (const [key, raw] of Object.entries(stored)) {
+    if (!key.startsWith(COUPANG_SELECTOR_CONFIG_CACHE_KEY_PREFIX)) {
+      continue;
+    }
+    const cached = await parseCachedConfigEntry(storage, key, raw);
+    if (!cached) {
+      continue;
+    }
+    if (!recovered || compareRecoveredCachePayloads(cached, recovered) > 0) {
+      recovered = cached;
+    }
+  }
+  if (!recovered) {
+    return;
+  }
+  return withSourceState(recovered, {
+    platform: "coupang",
+    source: "cache",
+    resolvedAt,
+    endpoint,
+    refreshWindowSeconds
+  });
+};
+var parseCoupangSelectorConfigResponse = (value) => {
+  if (!isRecord3(value)) {
+    return;
+  }
+  const selectors = value.selectors;
+  if (typeof value.version !== "string" || value.platform !== "coupang" || typeof value.generatedAt !== "string" || !isRecord3(selectors) || !isStringArray(selectors.loginIndicators) || !isStringArray(selectors.loggedOutIndicators) || !isStringArray(selectors.productTitle) || !isStringArray(selectors.productPrice) || !isOptionGroupArray(selectors.optionGroup) || !isStringArray(selectors.buyNowButton) || !isStringArray(selectors.addToCartButton) || !isStringArray(selectors.cartCheckoutButton) || !isStringArray(selectors.checkoutTotal)) {
+    return;
+  }
+  return {
+    version: value.version,
+    platform: "coupang",
+    generatedAt: value.generatedAt,
+    selectors: {
+      loginIndicators: [...selectors.loginIndicators],
+      loggedOutIndicators: [...selectors.loggedOutIndicators],
+      productTitle: [...selectors.productTitle],
+      productPrice: [...selectors.productPrice],
+      optionGroup: selectors.optionGroup.map((entry) => ({
+        container: entry.container,
+        items: entry.items,
+        ...entry.label ? { label: entry.label } : {}
+      })),
+      buyNowButton: [...selectors.buyNowButton],
+      addToCartButton: [...selectors.addToCartButton],
+      cartCheckoutButton: [...selectors.cartCheckoutButton],
+      checkoutTotal: [...selectors.checkoutTotal]
+    }
+  };
+};
+var normalizeBaseUrl = (value) => {
+  if (!value) {
+    return;
+  }
+  const trimmed = value.trim().replace(/\/+$/u, "");
+  return trimmed.length > 0 ? trimmed : undefined;
+};
+var withSourceState = (config, state) => ({
+  config,
+  source: {
+    ...state,
+    version: config.version,
+    generatedAt: config.generatedAt
+  }
+});
+var readSettings = async (storage, fallback) => {
+  const stored = await storage.get(SELECTOR_CONFIG_SETTINGS_STORAGE_KEY);
+  const raw = stored[SELECTOR_CONFIG_SETTINGS_STORAGE_KEY];
+  const value = isRecord3(raw) ? raw : {};
+  return {
+    baseUrl: typeof value.baseUrl === "string" ? value.baseUrl : fallback?.baseUrl,
+    refreshWindowSeconds: typeof value.refreshWindowSeconds === "number" ? value.refreshWindowSeconds : fallback?.refreshWindowSeconds,
+    timeoutMs: typeof value.timeoutMs === "number" ? value.timeoutMs : fallback?.timeoutMs
+  };
+};
+var readCacheMeta = async (storage) => {
+  const stored = await storage.get(SELECTOR_CONFIG_CACHE_META_STORAGE_KEY);
+  const raw = stored[SELECTOR_CONFIG_CACHE_META_STORAGE_KEY];
+  if (raw === undefined) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = parseStoredValue(raw);
+  } catch {
+    await invalidateMalformedCacheEntries(storage, SELECTOR_CONFIG_CACHE_META_STORAGE_KEY);
+    return;
+  }
+  if (!isRecord3(parsed) || typeof parsed.version !== "string" || typeof parsed.fetchedAt !== "string" || typeof parsed.endpoint !== "string") {
+    await invalidateMalformedCacheEntries(storage, SELECTOR_CONFIG_CACHE_META_STORAGE_KEY);
+    return;
+  }
+  return {
+    version: parsed.version,
+    fetchedAt: parsed.fetchedAt,
+    endpoint: parsed.endpoint
+  };
+};
+var readCachedConfig = async (storage, meta, refreshWindowSeconds, resolvedAt) => {
+  if (!meta) {
+    return;
+  }
+  const cacheKey = getSelectorConfigCacheStorageKey("coupang", meta.version);
+  const stored = await storage.get(cacheKey);
+  const raw = stored[cacheKey];
+  if (raw === undefined) {
+    return;
+  }
+  const cached = await parseCachedConfigEntry(storage, cacheKey, raw);
+  if (!cached) {
+    return;
+  }
+  return withSourceState(cached, {
+    platform: "coupang",
+    source: "cache",
+    resolvedAt,
+    endpoint: meta.endpoint,
+    refreshWindowSeconds
+  });
+};
+var fetchWithTimeout = async (input, fetchImpl, timeoutMs) => {
+  return await Promise.race([
+    fetchImpl(input, {
+      method: "GET",
+      headers: {
+        accept: "application/json"
+      }
+    }),
+    new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`selector_config_timeout:${timeoutMs}`)), timeoutMs);
+    })
+  ]);
+};
+var resolveCoupangSelectorConfig = async (options) => {
+  const now = options.now ?? (() => Date.now());
+  const resolvedAt = new Date(now()).toISOString();
+  const settings = await readSettings(options.storage, options.settings);
+  const refreshWindowSeconds = settings.refreshWindowSeconds ?? DEFAULT_SELECTOR_CONFIG_REFRESH_WINDOW_SECONDS;
+  const timeoutMs = settings.timeoutMs ?? DEFAULT_SELECTOR_CONFIG_TIMEOUT_MS;
+  const baseUrl = normalizeBaseUrl(settings.baseUrl);
+  if (!baseUrl) {
+    return withSourceState(BUNDLED_COUPANG_SELECTOR_CONFIG, {
+      platform: "coupang",
+      source: "bundled",
+      resolvedAt,
+      refreshWindowSeconds
+    });
+  }
+  const endpoint = `${baseUrl}/coupang/v1`;
+  const meta = await readCacheMeta(options.storage);
+  const cacheAgeMs = meta ? now() - new Date(meta.fetchedAt).getTime() : Number.POSITIVE_INFINITY;
+  const cached = meta ? await readCachedConfig(options.storage, meta, refreshWindowSeconds, resolvedAt) : await readRecoveredCachedConfig(options.storage, refreshWindowSeconds, resolvedAt, endpoint);
+  if (cached && Number.isFinite(cacheAgeMs) && cacheAgeMs < refreshWindowSeconds * 1000) {
+    return cached;
+  }
+  const fetchImpl = options.fetchImpl ?? fetch;
+  try {
+    const response = await fetchWithTimeout(endpoint, fetchImpl, timeoutMs);
+    if (!response.ok) {
+      throw new Error(`selector_config_http_${response.status}`);
+    }
+    const parsed = parseCoupangSelectorConfigResponse(await response.json());
+    if (!parsed) {
+      throw new Error("selector_config_invalid_shape");
+    }
+    await options.storage.set({
+      [getSelectorConfigCacheStorageKey(parsed.platform, parsed.version)]: parsed,
+      [SELECTOR_CONFIG_CACHE_META_STORAGE_KEY]: {
+        version: parsed.version,
+        fetchedAt: resolvedAt,
+        endpoint
+      }
+    });
+    return withSourceState(parsed, {
+      platform: "coupang",
+      source: "remote",
+      resolvedAt,
+      endpoint,
+      refreshWindowSeconds
+    });
+  } catch {
+    if (cached) {
+      return cached;
+    }
+    return withSourceState(BUNDLED_COUPANG_SELECTOR_CONFIG, {
+      platform: "coupang",
+      source: "bundled",
+      resolvedAt,
+      endpoint,
+      refreshWindowSeconds
+    });
+  }
+};
+
+// extension/background.ts
+var storageArea2 = chrome.storage?.session ?? chrome.storage?.local;
+var localStorageArea = chrome.storage?.local ?? chrome.storage?.session;
+var COUPANG_URL_FILTER = ["*://*.coupang.com/*"];
+var NATIVE_REQUEST_TIMEOUT_MS = 5000;
+var createRequestId = () => globalThis.crypto?.randomUUID?.() ?? `req_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+var toErrorMessage = (error) => error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown extension error";
+var readStoredState = async () => {
+  if (!storageArea2) {
+    return {};
+  }
+  const stored = await storageArea2.get(EXTENSION_RUNTIME_STATE_KEY);
+  return stored[EXTENSION_RUNTIME_STATE_KEY] ?? {};
+};
+var writeStoredState = async (patch) => {
+  const next = {
+    ...await readStoredState(),
+    ...patch,
+    lastUpdatedAt: new Date().toISOString()
+  };
+  if (storageArea2) {
+    await storageArea2.set({
+      [EXTENSION_RUNTIME_STATE_KEY]: next
+    });
+  }
+  return next;
+};
+var writeOrderCheckpointToStorage = async (checkpoint) => {
+  if (!storageArea2) {
+    return checkpoint;
+  }
+  await storageArea2.set({
+    [getOrderCheckpointStorageKey(checkpoint.orderId)]: checkpoint
+  });
+  return checkpoint;
+};
+var listActiveOrderCheckpoints = async () => {
+  if (!storageArea2) {
+    return [];
+  }
+  const stored = await storageArea2.get(null);
+  return Object.entries(stored).filter(([key, value]) => key.startsWith("buygentOrderCheckpoint:") && Boolean(value)).map(([, value]) => value).filter((checkpoint) => !isTerminalOrderState(checkpoint.state));
+};
+var selectorConfigPromise;
+var ensureSelectorConfig = async () => {
+  if (!localStorageArea) {
+    return await resolveCoupangSelectorConfig({
+      storage: {
+        async get() {
+          return {};
+        },
+        async set() {},
+        async remove() {}
+      }
+    });
+  }
+  if (!selectorConfigPromise) {
+    selectorConfigPromise = resolveCoupangSelectorConfig({
+      storage: localStorageArea
+    }).finally(() => {
+      selectorConfigPromise = undefined;
+    });
+  }
+  const resolved = await selectorConfigPromise;
+  await writeStoredState({
+    selectorConfig: resolved.source
+  });
+  return resolved;
+};
+var getActiveTab = async () => {
+  const [tab] = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+  if (!tab?.id) {
+    throw new Error("No active tab found.");
+  }
+  return tab;
+};
+var wait = async (ms) => {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+};
+var waitForTabReady = async (tabId, timeoutMs = 1e4) => {
+  const current = await chrome.tabs.get(tabId);
+  if (current?.status === "complete") {
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      chrome.tabs.onUpdated.removeListener(listener);
+      reject(new Error(`Timed out waiting for Coupang tab ${tabId} to finish loading.`));
+    }, timeoutMs);
+    const listener = (updatedTabId, changeInfo) => {
+      if (updatedTabId !== tabId || changeInfo.status !== "complete") {
+        return;
+      }
+      clearTimeout(timeout);
+      chrome.tabs.onUpdated.removeListener(listener);
+      resolve();
+    };
+    chrome.tabs.onUpdated.addListener(listener);
+  });
+};
+var ensureCoupangTab = async (productUrl) => {
+  const existingTabs = await chrome.tabs.query({ url: COUPANG_URL_FILTER });
+  const exactMatch = existingTabs.find((tab) => typeof tab.id === "number" && tab.url === productUrl);
+  if (exactMatch?.id) {
+    await chrome.tabs.update(exactMatch.id, { active: true });
+    if (typeof exactMatch.windowId === "number") {
+      await chrome.windows.update(exactMatch.windowId, { focused: true });
+    }
+    return exactMatch;
+  }
+  const anyCoupang = existingTabs.find((tab) => typeof tab.id === "number");
+  if (anyCoupang?.id) {
+    const updated = await chrome.tabs.update(anyCoupang.id, { active: true, url: productUrl });
+    if (typeof updated?.windowId === "number") {
+      await chrome.windows.update(updated.windowId, { focused: true });
+    }
+    return updated;
+  }
+  return await chrome.tabs.create({ url: productUrl, active: true });
+};
+var sendMessageToTab = async (tabId, envelope, attempts = 4) => {
+  let lastError;
+  for (let attempt = 1;attempt <= attempts; attempt += 1) {
+    try {
+      return await chrome.tabs.sendMessage(tabId, envelope);
+    } catch (error) {
+      lastError = error;
+      await wait(attempt * 250);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("The Coupang content script did not respond.");
+};
+var nativePort;
+var pendingNativeResponses = new Map;
+var postToNativeHost = (envelope) => {
+  if (!nativePort) {
+    throw new Error("The Buygent native host is not connected.");
+  }
+  nativePort.postMessage(envelope);
+};
+var routeOrderStartFromNativeHost = async (message) => {
+  const tab = await ensureCoupangTab(message.payload.productUrl);
+  if (!tab?.id) {
+    throw new Error("Unable to open or focus a Coupang tab for the dry-run order.");
+  }
+  await waitForTabReady(tab.id);
+  const selectorConfig = await ensureSelectorConfig();
+  const startPayload = {
+    ...message.payload,
+    tabId: tab.id
+  };
+  const response = await sendMessageToTab(tab.id, createEnvelope("order:start", {
+    ...startPayload,
+    selectorConfig
+  }, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: message.messageId
+  }));
+  const decoded = decodeEnvelope(response, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: message.messageId
+  });
+  if (!decoded.ok) {
+    throw new Error(decoded.error.payload.message);
+  }
+  await writeStoredState({
+    activeTabUrl: typeof tab.url === "string" ? tab.url : message.payload.productUrl,
+    lastError: undefined,
+    selectorConfig: selectorConfig.source
+  });
+  return createEnvelope("order:ack", {
+    orderId: message.payload.orderId,
+    accepted: true,
+    tabId: tab.id
+  }, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: message.messageId
+  });
+};
+var routeRuntimeStateRequestFromNativeHost = async (message) => {
+  const selectorConfig = await ensureSelectorConfig();
+  const state = await writeStoredState({
+    selectorConfig: selectorConfig.source
+  });
+  return createEnvelope("runtime:state", { state }, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: message.messageId
+  });
+};
+var handleNativeHostMessage = async (rawMessage) => {
+  const decoded = decodeEnvelope(rawMessage, {
+    source: "extension:background",
+    messageId: createRequestId()
+  });
+  if (!decoded.ok) {
+    return;
+  }
+  const message = decoded.envelope;
+  if (message.requestId && pendingNativeResponses.has(message.requestId)) {
+    const pending = pendingNativeResponses.get(message.requestId);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      pendingNativeResponses.delete(message.requestId);
+      pending.resolve(message);
+      return;
+    }
+  }
+  if (message.type === "order:start") {
+    try {
+      postToNativeHost(await routeOrderStartFromNativeHost(message));
+    } catch (error) {
+      postToNativeHost(createErrorEnvelope({
+        code: "internal_error",
+        message: toErrorMessage(error),
+        details: {
+          orderId: message.payload.orderId
+        }
+      }, {
+        source: "extension:background",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      }));
+      await writeStoredState({
+        lastError: toErrorMessage(error)
+      });
+    }
+    return;
+  }
+  if (message.type === "runtime:get-state") {
+    try {
+      postToNativeHost(await routeRuntimeStateRequestFromNativeHost(message));
+    } catch (error) {
+      postToNativeHost(createErrorEnvelope({
+        code: "internal_error",
+        message: toErrorMessage(error)
+      }, {
+        source: "extension:background",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      }));
+      await writeStoredState({
+        lastError: toErrorMessage(error)
+      });
+    }
+  }
+};
+var ensureNativePort = async () => {
+  if (nativePort) {
+    return nativePort;
+  }
+  nativePort = chrome.runtime.connectNative(BUYGENT_NATIVE_HOST_NAME);
+  nativePort.onMessage.addListener((message) => {
+    handleNativeHostMessage(message);
+  });
+  nativePort.onDisconnect.addListener(() => {
+    nativePort = undefined;
+    for (const pending of pendingNativeResponses.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error(chrome.runtime.lastError?.message ?? "The Buygent native host disconnected."));
+    }
+    pendingNativeResponses.clear();
+  });
+  return nativePort;
+};
+var sendNativePingRequest = async (payload) => {
+  await ensureNativePort();
+  const request = createEnvelope("native:ping", payload, {
+    source: "extension:background",
+    messageId: createRequestId()
+  });
+  const responsePromise = new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      pendingNativeResponses.delete(request.messageId);
+      reject(new Error("Timed out waiting for native host response to native:ping."));
+    }, NATIVE_REQUEST_TIMEOUT_MS);
+    pendingNativeResponses.set(request.messageId, { resolve, reject, timeout });
+  });
+  postToNativeHost(request);
+  return await responsePromise;
+};
+var getStateResponse = async (request) => {
+  const current = await readStoredState();
+  const selectorConfig = await ensureSelectorConfig();
+  try {
+    const activeTab = await getActiveTab();
+    const state = await writeStoredState({
+      ...current,
+      activeTabUrl: activeTab.url,
+      selectorConfig: selectorConfig.source
+    });
+    return createEnvelope("popup:state", { state }, {
+      source: "extension:background",
+      messageId: createRequestId(),
+      requestId: request.messageId
+    });
+  } catch {
+    const state = await writeStoredState({
+      ...current,
+      selectorConfig: selectorConfig.source
+    });
+    return createEnvelope("popup:state", { state }, {
+      source: "extension:background",
+      messageId: createRequestId(),
+      requestId: request.messageId
+    });
+  }
+};
+var requestCoupangProbe = async (request) => {
+  const activeTab = await getActiveTab();
+  const activeTabUrl = typeof activeTab.url === "string" ? activeTab.url : undefined;
+  if (!activeTabUrl?.includes("coupang.com")) {
+    throw new Error("Open a Coupang tab before probing the active page.");
+  }
+  const selectorConfig = await ensureSelectorConfig();
+  const response = await sendMessageToTab(activeTab.id, createEnvelope("coupang:probe", { selectorConfig }, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: request.messageId
+  }));
+  const decoded = decodeEnvelope(response, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: request.messageId
+  });
+  if (!decoded.ok) {
+    throw new Error(decoded.error.payload.message);
+  }
+  if (decoded.envelope.type === "error") {
+    throw new Error(decoded.envelope.payload.message);
+  }
+  const probeEnvelope = decoded.envelope;
+  const probe = probeEnvelope.payload.probe;
+  const state = await writeStoredState({
+    lastProbe: probe,
+    activeTabUrl,
+    lastError: undefined,
+    selectorConfig: selectorConfig.source
+  });
+  return createEnvelope("popup:probe-result", {
+    probe,
+    state
+  }, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: request.messageId
+  });
+};
+var pingNativeHost = async (request) => {
+  const response = await sendNativePingRequest({
+    extensionVersion: chrome.runtime.getManifest().version
+  });
+  const nativeHostResponse = response;
+  const state = await writeStoredState({
+    lastNativeHostResponse: nativeHostResponse,
+    lastError: response.type === "error" ? response.payload.message : undefined
+  });
+  return createEnvelope("popup:native-host-response", {
+    response: nativeHostResponse,
+    state
+  }, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: request.messageId
+  });
+};
+var toPopupError = async (requestId, error) => {
+  await writeStoredState({
+    lastError: toErrorMessage(error)
+  });
+  return createErrorEnvelope({
+    code: "internal_error",
+    message: toErrorMessage(error)
+  }, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId
+  });
+};
+var relayOrderUpdateToNativeHost = async (message) => {
+  await ensureNativePort();
+  postToNativeHost(createEnvelope(message.type, message.payload, {
+    source: "extension:background",
+    messageId: createRequestId(),
+    requestId: message.requestId
+  }));
+  await writeStoredState({
+    ...message.type === "order:status" ? {
+      lastOrderStatus: message.payload
+    } : {
+      lastOrderCheckpoint: message.payload
+    },
+    activeTabUrl: message.payload.pageUrl,
+    lastError: message.payload.lastError
+  });
+};
+var maybeResumeStoredOrder = async (tabId, url) => {
+  const activeCheckpoints = await listActiveOrderCheckpoints();
+  const selectorConfig = await ensureSelectorConfig();
+  await dispatchStoredOrderResume({
+    checkpoints: activeCheckpoints,
+    tabId,
+    url,
+    writeCheckpoint: writeOrderCheckpointToStorage,
+    sendResume: async (envelope) => {
+      await sendMessageToTab(tabId, {
+        ...envelope,
+        payload: {
+          ...envelope.payload,
+          selectorConfig
+        }
+      });
+    },
+    createMessageId: createRequestId
+  }).catch(() => {
+    return;
+  });
+};
+var handleRuntimeMessage = async (rawMessage, sender) => {
+  const decoded = decodeEnvelope(rawMessage, {
+    source: "extension:background",
+    messageId: createRequestId()
+  });
+  if (!decoded.ok) {
+    return decoded.error;
+  }
+  const message = decoded.envelope;
+  switch (message.type) {
+    case "popup:get-state":
+      return await getStateResponse(message);
+    case "popup:probe-active-tab":
+      return await requestCoupangProbe(message);
+    case "popup:ping-native-host":
+      return await pingNativeHost(message);
+    case "content:ready":
+      if (typeof sender.tab?.id === "number") {
+        maybeResumeStoredOrder(sender.tab.id, message.payload.url);
+      }
+      return createEnvelope("content:ack", { ok: true }, {
+        source: "extension:background",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      });
+    case "order:status":
+    case "order:checkpoint":
+      await relayOrderUpdateToNativeHost(message);
+      return createEnvelope("content:ack", { orderId: message.payload.orderId, ok: true }, {
+        source: "extension:background",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      });
+    case "error":
+      await writeStoredState({
+        lastError: message.payload.message
+      });
+      await relayOrderScopedErrorEnvelope(message, {
+        ensureNativePort,
+        postToNativeHost
+      }).catch(() => {
+        return;
+      });
+      return createEnvelope("content:ack", {
+        ...getOrderIdFromErrorEnvelope(message) ? { orderId: getOrderIdFromErrorEnvelope(message) } : {},
+        ok: true
+      }, {
+        source: "extension:background",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      });
+    default:
+      return createErrorEnvelope({
+        code: "unsupported_message",
+        message: `Unsupported extension runtime message: ${message.type ?? "unknown"}`
+      }, {
+        source: "extension:background",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      });
+  }
+};
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  handleRuntimeMessage(message, sender).then(sendResponse).catch(async (error) => sendResponse(await toPopupError(message?.messageId, error)));
+  return true;
+});
+chrome.runtime.onStartup?.addListener(() => {
+  ensureNativePort().catch(() => {
+    return;
+  });
+  ensureSelectorConfig().catch(() => {
+    return;
+  });
+});
+chrome.runtime.onInstalled?.addListener(() => {
+  ensureNativePort().catch(() => {
+    return;
+  });
+  ensureSelectorConfig().catch(() => {
+    return;
+  });
+});
+ensureNativePort().catch(() => {
+  return;
+});
+ensureSelectorConfig().catch(() => {
+  return;
+});