feat: Complete zCode CLI X with Telegram bot integration

- Add full Telegram bot functionality with Z.AI API integration
- Implement 4 tools: Bash, FileEdit, WebSearch, Git
- Add 3 agents: Code Reviewer, Architect, DevOps Engineer
- Add 6 skills for common coding tasks
- Add systemd service file for 24/7 operation
- Add nginx configuration for HTTPS webhook
- Add comprehensive documentation
- Implement WebSocket server for real-time updates
- Add logging system with Winston
- Add environment validation

🤖 zCode CLI X - Agentic coder with Z.AI + Telegram integration

~/.npm-cache/@growthbook/growthbook@1.6.5@@@1/dist/cjs/plugins/auto-attributes.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.autoAttributesPlugin = autoAttributesPlugin;
+function getBrowserDevice(ua) {
+  const browser = ua.match(/Edg/) ? "edge" : ua.match(/Chrome/) ? "chrome" : ua.match(/Firefox/) ? "firefox" : ua.match(/Safari/) ? "safari" : "unknown";
+  const deviceType = ua.match(/Mobi/) ? "mobile" : "desktop";
+  return {
+    browser,
+    deviceType
+  };
+}
+function getURLAttributes(url) {
+  if (!url) return {};
+  return {
+    url: url.href,
+    path: url.pathname,
+    host: url.host,
+    query: url.search
+  };
+}
+function autoAttributesPlugin(settings = {}) {
+  // Browser only
+  if (typeof window === "undefined") {
+    throw new Error("autoAttributesPlugin only works in the browser");
+  }
+  const COOKIE_NAME = settings.uuidCookieName || "gbuuid";
+  const uuidKey = settings.uuidKey || "id";
+  let uuid = settings.uuid || "";
+  function persistUUID() {
+    setCookie(COOKIE_NAME, uuid);
+  }
+  function getUUID() {
+    // Already stored in memory, return
+    if (uuid) return uuid;
+
+    // If cookie is already set, return
+    uuid = getCookie(COOKIE_NAME);
+    if (uuid) return uuid;
+
+    // Generate a new UUID
+    uuid = genUUID(window.crypto);
+    return uuid;
+  }
+
+  // Listen for a custom event to persist the UUID cookie
+  document.addEventListener("growthbookpersist", () => {
+    persistUUID();
+  });
+  function getAutoAttributes(settings) {
+    const ua = navigator.userAgent;
+    const _uuid = getUUID();
+
+    // If a uuid is provided, default persist to false, otherwise default to true
+    if (settings.uuidAutoPersist ?? !settings.uuid) {
+      persistUUID();
+    }
+    const url = location;
+    return {
+      ...getDataLayerVariables(),
+      [uuidKey]: _uuid,
+      ...getURLAttributes(url),
+      pageTitle: document.title,
+      ...getBrowserDevice(ua),
+      ...getUtmAttributes(url)
+    };
+  }
+  return gb => {
+    // Only works for instances with user attributes
+    if ("createScopedInstance" in gb) {
+      return;
+    }
+
+    // Set initial attributes
+    const attributes = getAutoAttributes(settings);
+    attributes.url && gb.setURL(attributes.url);
+    gb.updateAttributes(attributes);
+
+    // Poll for URL changes and update GrowthBook
+    let currentUrl = attributes.url;
+    const intervalTimer = setInterval(() => {
+      if (location.href !== currentUrl) {
+        currentUrl = location.href;
+        gb.setURL(currentUrl);
+        gb.updateAttributes(getAutoAttributes(settings));
+      }
+    }, 500);
+
+    // Listen for a custom event to update URL and attributes
+    const refreshListener = () => {
+      if (location.href !== currentUrl) {
+        currentUrl = location.href;
+        gb.setURL(currentUrl);
+      }
+      gb.updateAttributes(getAutoAttributes(settings));
+    };
+    document.addEventListener("growthbookrefresh", refreshListener);
+    if ("onDestroy" in gb) {
+      gb.onDestroy(() => {
+        clearInterval(intervalTimer);
+        document.removeEventListener("growthbookrefresh", refreshListener);
+      });
+    }
+  };
+}
+function setCookie(name, value) {
+  const d = new Date();
+  const COOKIE_DAYS = 400; // 400 days is the max cookie duration for chrome
+  d.setTime(d.getTime() + 24 * 60 * 60 * 1000 * COOKIE_DAYS);
+  document.cookie = name + "=" + value + ";path=/;expires=" + d.toUTCString();
+}
+function getCookie(name) {
+  const value = "; " + document.cookie;
+  const parts = value.split(`; ${name}=`);
+  return parts.length === 2 ? parts[1].split(";")[0] : "";
+}
+
+// Use the browsers crypto.randomUUID if set to generate a UUID
+function genUUID(crypto) {
+  if (crypto && crypto.randomUUID) return crypto.randomUUID();
+  return ("" + 1e7 + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => {
+    const n = crypto && crypto.getRandomValues ? crypto.getRandomValues(new Uint8Array(1))[0] : Math.floor(Math.random() * 256);
+    return (c ^ n & 15 >> c / 4).toString(16);
+  });
+}
+function getUtmAttributes(url) {
+  // Store utm- params in sessionStorage for future page loads
+  let utms = {};
+  try {
+    const existing = sessionStorage.getItem("utm_params");
+    if (existing) {
+      utms = JSON.parse(existing);
+    }
+  } catch (e) {
+    // Do nothing if sessionStorage is disabled (e.g. incognito window)
+  }
+
+  // Add utm params from querystring
+  if (url && url.search) {
+    const params = new URLSearchParams(url.search);
+    let hasChanges = false;
+    ["source", "medium", "campaign", "term", "content"].forEach(k => {
+      // Querystring is in snake_case
+      const param = `utm_${k}`;
+      // Attribute keys are camelCase
+      const attr = `utm` + k[0].toUpperCase() + k.slice(1);
+      if (params.has(param)) {
+        utms[attr] = params.get(param) || "";
+        hasChanges = true;
+      }
+    });
+
+    // Write back to sessionStorage
+    if (hasChanges) {
+      try {
+        sessionStorage.setItem("utm_params", JSON.stringify(utms));
+      } catch (e) {
+        // Do nothing if sessionStorage is disabled (e.g. incognito window)
+      }
+    }
+  }
+  return utms;
+}
+function getDataLayerVariables() {
+  if (typeof window === "undefined" || !window.dataLayer || !window.dataLayer.forEach) {
+    return {};
+  }
+  const obj = {};
+  window.dataLayer.forEach(item => {
+    // Skip empty and non-object entries
+    if (!item || typeof item !== "object" || "length" in item) return;
+
+    // Skip events
+    if ("event" in item) return;
+    Object.keys(item).forEach(k => {
+      // Filter out known properties that aren't useful
+      if (typeof k !== "string" || k.match(/^(gtm)/)) return;
+      const val = item[k];
+
+      // Only add primitive variable values
+      const valueType = typeof val;
+      if (["string", "number", "boolean"].includes(valueType)) {
+        obj[k] = val;
+      }
+    });
+  });
+  return obj;
+}
+//# sourceMappingURL=auto-attributes.js.map

~/.npm-cache/@growthbook/growthbook@1.6.5@@@1/dist/cjs/plugins/devtools.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.devtoolsExpressPlugin = devtoolsExpressPlugin;
+exports.devtoolsNextjsPlugin = devtoolsNextjsPlugin;
+exports.devtoolsPlugin = devtoolsPlugin;
+exports.getDebugEvent = getDebugEvent;
+exports.getDebugScriptContents = getDebugScriptContents;
+var _GrowthBook = require("../GrowthBook");
+var _GrowthBookClient = require("../GrowthBookClient");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+function applyDevtoolsState(devtoolsState, gb) {
+  // Only enable in dev mode
+  if (!gb.inDevMode()) {
+    return;
+  }
+  if (devtoolsState.attributes && typeof devtoolsState.attributes === "object") {
+    gb.setAttributeOverrides(devtoolsState.attributes);
+  }
+  if (devtoolsState.features && typeof devtoolsState.features === "object") {
+    const map = new Map(Object.entries(devtoolsState.features));
+    gb.setForcedFeatures(map);
+  }
+  if (devtoolsState.experiments && typeof devtoolsState.experiments === "object") {
+    gb.setForcedVariations(devtoolsState.experiments);
+  }
+}
+function devtoolsPlugin(devtoolsState) {
+  return gb => {
+    // Only works for user-scoped GrowthBook instances
+    if ("createScopedInstance" in gb) {
+      throw new Error("devtoolsPlugin can only be set on a user-scoped instance");
+    }
+    if (devtoolsState) {
+      applyDevtoolsState(devtoolsState, gb);
+    }
+  };
+}
+
+/**
+ * For NextJS environments.
+ * When using server components, use the `searchParams` and `requestCookies` fields.
+ *  - Note: In NextJS 15+, you should await these values before passing them to the plugin
+ * When using middleware / api routes, provide the `request` field instead.
+ */
+function devtoolsNextjsPlugin({
+  searchParams,
+  requestCookies,
+  request
+}) {
+  function extractGbDebugPayload({
+    searchParams,
+    requestCookies
+  }) {
+    if (searchParams) {
+      if ("_gbdebug" in searchParams) {
+        return searchParams._gbdebug;
+      }
+      if (searchParams instanceof URLSearchParams) {
+        return searchParams.get("_gbdebug") ?? undefined;
+      }
+    }
+    return requestCookies?.get("_gbdebug")?.value;
+  }
+  return gb => {
+    let payload = extractGbDebugPayload({
+      searchParams,
+      requestCookies
+    });
+    if (!payload && request) {
+      payload = extractGbDebugPayload({
+        searchParams: request.nextUrl.searchParams,
+        requestCookies: request.cookies
+      });
+    }
+    let state = {};
+    if (payload) {
+      try {
+        state = JSON.parse(payload);
+      } catch (e) {
+        console.error("cannot parse devtools payload", e);
+      }
+    }
+    devtoolsPlugin(state)(gb);
+  };
+}
+
+/**
+ * Intended to be used with cookieParser() middleware from npm: 'cookie-parser'.
+ */
+function devtoolsExpressPlugin({
+  request
+}) {
+  return gb => {
+    let payload = typeof request?.query?.["_gbdebug"] === "string" ? request.query["_gbdebug"] : undefined;
+    if (!payload) {
+      payload = typeof request?.cookies?.["_gbdebug"] === "string" ? request.cookies["_gbdebug"] : undefined;
+    }
+    let state = {};
+    if (payload) {
+      try {
+        state = JSON.parse(payload);
+      } catch (e) {
+        console.error("cannot parse devtools payload", e);
+      }
+    }
+    devtoolsPlugin(state)(gb);
+  };
+}
+/**
+ * Helper method to get debug script contents for DevTools
+ * @param gb - GrowthBook instance. DevMode must be enabled to view log events.
+ * @param {string} [source] - Label these events for ease of reading in DevTools
+ * @example
+ * A React logger component (implement yourself):
+ ```
+  return (
+    <script dangerouslySetInnerHTML={{
+      __html: getDebugScriptContents(gb, "nextjs")
+    }} />
+  );
+ ```
+ */
+function getDebugScriptContents(gb, source) {
+  const event = getDebugEvent(gb, source);
+  if (!event) return "";
+  return `(window._gbdebugEvents = (window._gbdebugEvents || [])).push(${JSON.stringify(event)});`;
+}
+function getDebugEvent(gb, source) {
+  if (!("logs" in gb)) return null;
+  // Only enable in dev mode
+  if (!gb.inDevMode()) {
+    return null;
+  }
+  if (gb instanceof _GrowthBook.GrowthBook) {
+    // GrowthBook SDK
+    const [apiHost, clientKey] = gb.getApiInfo();
+    return {
+      logs: gb.logs,
+      sdkInfo: {
+        apiHost,
+        clientKey,
+        source,
+        version: gb.version,
+        payload: gb.getDecryptedPayload(),
+        attributes: gb.getAttributes()
+      }
+    };
+  } else if (gb instanceof _GrowthBookClient.UserScopedGrowthBook) {
+    // UserScopedGrowthBook SDK
+    const userContext = gb.getUserContext();
+    const [apiHost, clientKey] = gb.getApiInfo();
+    return {
+      logs: gb.logs,
+      sdkInfo: {
+        apiHost,
+        clientKey,
+        source,
+        version: gb.getVersion(),
+        payload: gb.getDecryptedPayload(),
+        attributes: {
+          ...userContext.attributes,
+          ...userContext.attributeOverrides
+        }
+      }
+    };
+  }
+  return null;
+}
+//# sourceMappingURL=devtools.js.map

~/.npm-cache/@growthbook/growthbook@1.6.5@@@1/dist/cjs/plugins/growthbook-tracking.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.growthbookTrackingPlugin = growthbookTrackingPlugin;
+var _util = require("../util");
+var _core = require("../core");
+const SDK_VERSION = (0, _util.loadSDKVersion)();
+function parseString(value) {
+  return typeof value === "string" ? value : null;
+}
+function parseAttributes(attributes) {
+  const {
+    user_id,
+    device_id,
+    anonymous_id,
+    id,
+    page_id,
+    session_id,
+    utmCampaign,
+    utmContent,
+    utmMedium,
+    utmSource,
+    utmTerm,
+    pageTitle,
+    ...nested
+  } = attributes;
+  return {
+    nested,
+    topLevel: {
+      user_id: parseString(user_id),
+      device_id: parseString(device_id || anonymous_id || id),
+      page_id: parseString(page_id),
+      session_id: parseString(session_id),
+      utm_campaign: parseString(utmCampaign) || undefined,
+      utm_content: parseString(utmContent) || undefined,
+      utm_medium: parseString(utmMedium) || undefined,
+      utm_source: parseString(utmSource) || undefined,
+      utm_term: parseString(utmTerm) || undefined,
+      page_title: parseString(pageTitle) || undefined
+    }
+  };
+}
+function getEventPayload({
+  eventName,
+  properties,
+  attributes,
+  url
+}) {
+  const {
+    nested,
+    topLevel
+  } = parseAttributes(attributes || {});
+  return {
+    event_name: eventName,
+    properties_json: properties || {},
+    ...topLevel,
+    sdk_language: "js",
+    sdk_version: SDK_VERSION,
+    url: url,
+    context_json: nested
+  };
+}
+async function track({
+  clientKey,
+  ingestorHost,
+  events
+}) {
+  if (!events.length) return;
+  const endpoint = `${ingestorHost || "https://us1.gb-ingest.com"}/track?client_key=${clientKey}`;
+  const body = JSON.stringify(events);
+  try {
+    await fetch(endpoint, {
+      method: "POST",
+      body,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "text/plain"
+      },
+      credentials: "omit"
+    });
+  } catch (e) {
+    console.error("Failed to track event", e);
+  }
+}
+function growthbookTrackingPlugin({
+  queueFlushInterval = 100,
+  ingestorHost,
+  enable = true,
+  debug,
+  dedupeCacheSize = 1000,
+  dedupeKeyAttributes = [],
+  eventFilter
+} = {}) {
+  return gb => {
+    const clientKey = gb.getClientKey();
+    if (!clientKey) {
+      throw new Error("clientKey must be specified to use event logging");
+    }
+
+    // LRU cache for events to avoid duplicates
+    const eventCache = new Set();
+    if ("setEventLogger" in gb) {
+      let _q = [];
+      let timer = null;
+      const flush = async () => {
+        const events = _q;
+        _q = [];
+        timer && clearTimeout(timer);
+        timer = null;
+        events.length && (await track({
+          clientKey,
+          events,
+          ingestorHost
+        }));
+      };
+      let promise = null;
+      gb.setEventLogger(async (eventName, properties, userContext) => {
+        const data = {
+          eventName,
+          properties,
+          attributes: userContext.attributes || {},
+          url: userContext.url || ""
+        };
+
+        // Skip logging if the event is being filtered
+        if (eventFilter && !eventFilter(data)) {
+          return;
+        }
+
+        // De-dupe Feature Evaluated and Experiment Viewed events
+        if (eventName === _core.EVENT_FEATURE_EVALUATED || eventName === _core.EVENT_EXPERIMENT_VIEWED) {
+          // Build the key for de-duping
+          const dedupeKeyData = {
+            eventName,
+            properties
+          };
+          for (const key of dedupeKeyAttributes) {
+            dedupeKeyData["attr:" + key] = data.attributes[key];
+          }
+          const k = JSON.stringify(dedupeKeyData);
+          // Duplicate event fired recently, move to end of LRU cache and skip
+          if (eventCache.has(k)) {
+            eventCache.delete(k);
+            eventCache.add(k);
+            return;
+          }
+          eventCache.add(k);
+
+          // If the cache is too big, remove the oldest item
+          if (eventCache.size > dedupeCacheSize) {
+            const oldest = eventCache.values().next().value;
+            oldest && eventCache.delete(oldest);
+          }
+        }
+        const payload = getEventPayload(data);
+        debug && console.log("Logging event to GrowthBook", JSON.parse(JSON.stringify(payload)));
+        if (!enable) return;
+        _q.push(payload);
+
+        // Only one in-progress promise at a time
+        if (!promise) {
+          promise = new Promise((resolve, reject) => {
+            // Flush the queue after a delay
+            timer = setTimeout(() => {
+              flush().then(resolve).catch(reject);
+              promise = null;
+            }, queueFlushInterval);
+          });
+        }
+        await promise;
+      });
+
+      // Flush the queue on page unload
+      if (typeof document !== "undefined" && document.visibilityState) {
+        document.addEventListener("visibilitychange", () => {
+          if (document.visibilityState === "hidden") {
+            flush().catch(console.error);
+          }
+        });
+      }
+
+      // Flush the queue when the growthbook instance is destroyed
+      "onDestroy" in gb && gb.onDestroy(() => {
+        flush().catch(console.error);
+      });
+    }
+
+    // Listen on window.gbEvents.push if in a browser
+    // This makes it easier to integrate with Segment, GTM, etc.
+    if (typeof window !== "undefined" && !("createScopedInstance" in gb)) {
+      const prevEvents = Array.isArray(window.gbEvents) ? window.gbEvents : [];
+      window.gbEvents = {
+        push: event => {
+          if ("isDestroyed" in gb && gb.isDestroyed()) {
+            // If trying to log and the instance has been destroyed, switch back to just an array
+            // This will let the next GrowthBook instance pick it up
+            window.gbEvents = [event];
+            return;
+          }
+          if (typeof event === "string") {
+            gb.logEvent(event);
+          } else if (event) {
+            gb.logEvent(event.eventName, event.properties);
+          }
+        }
+      };
+      for (const event of prevEvents) {
+        window.gbEvents.push(event);
+      }
+    }
+  };
+}
+//# sourceMappingURL=growthbook-tracking.js.map

~/.npm-cache/@growthbook/growthbook@1.6.5@@@1/dist/cjs/plugins/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "autoAttributesPlugin", {
+  enumerable: true,
+  get: function () {
+    return _autoAttributes.autoAttributesPlugin;
+  }
+});
+Object.defineProperty(exports, "devtoolsExpressPlugin", {
+  enumerable: true,
+  get: function () {
+    return _devtools.devtoolsExpressPlugin;
+  }
+});
+Object.defineProperty(exports, "devtoolsNextjsPlugin", {
+  enumerable: true,
+  get: function () {
+    return _devtools.devtoolsNextjsPlugin;
+  }
+});
+Object.defineProperty(exports, "devtoolsPlugin", {
+  enumerable: true,
+  get: function () {
+    return _devtools.devtoolsPlugin;
+  }
+});
+Object.defineProperty(exports, "getDebugEvent", {
+  enumerable: true,
+  get: function () {
+    return _devtools.getDebugEvent;
+  }
+});
+Object.defineProperty(exports, "getDebugScriptContents", {
+  enumerable: true,
+  get: function () {
+    return _devtools.getDebugScriptContents;
+  }
+});
+Object.defineProperty(exports, "growthbookTrackingPlugin", {
+  enumerable: true,
+  get: function () {
+    return _growthbookTracking.growthbookTrackingPlugin;
+  }
+});
+Object.defineProperty(exports, "thirdPartyTrackingPlugin", {
+  enumerable: true,
+  get: function () {
+    return _thirdPartyTracking.thirdPartyTrackingPlugin;
+  }
+});
+var _autoAttributes = require("./auto-attributes");
+var _growthbookTracking = require("./growthbook-tracking");
+var _thirdPartyTracking = require("./third-party-tracking");
+var _devtools = require("./devtools");
+//# sourceMappingURL=index.js.map

~/.npm-cache/@growthbook/growthbook@1.6.5@@@1/dist/cjs/plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_autoAttributes","require","_growthbookTracking","_thirdPartyTracking","_devtools"],"sources":["../../../src/plugins/index.ts"],"sourcesContent":["export { autoAttributesPlugin } from \"./auto-attributes\";\nexport { growthbookTrackingPlugin } from \"./growthbook-tracking\";\nexport { thirdPartyTrackingPlugin } from \"./third-party-tracking\";\nexport {\n  devtoolsPlugin,\n  devtoolsNextjsPlugin,\n  devtoolsExpressPlugin,\n  getDebugScriptContents,\n  getDebugEvent,\n} from \"./devtools\";\n\n// Types must be exported separately, otherwise rollup includes them in the javascript output which breaks things\nexport type {\n  DevtoolsState,\n  ExpressRequestCompat,\n  NextjsReadonlyRequestCookiesCompat,\n  NextjsRequestCompat,\n  LogEvent,\n  SdkInfo,\n} from \"./devtools\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AACA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,mBAAA,GAAAF,OAAA;AACA,IAAAG,SAAA,GAAAH,OAAA","ignoreList":[]}

~/.npm-cache/@growthbook/growthbook@1.6.5@@@1/dist/cjs/plugins/third-party-tracking.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.thirdPartyTrackingPlugin = thirdPartyTrackingPlugin;
+function thirdPartyTrackingPlugin({
+  additionalCallback,
+  trackers = ["gtag", "gtm", "segment"]
+} = {}) {
+  // Browser only
+  if (typeof window === "undefined") {
+    throw new Error("thirdPartyTrackingPlugin only works in the browser");
+  }
+  return gb => {
+    gb.setTrackingCallback(async (e, r) => {
+      const promises = [];
+      const eventParams = {
+        experiment_id: e.key,
+        variation_id: r.key
+      };
+      if (additionalCallback) {
+        promises.push(Promise.resolve(additionalCallback(e, r)));
+      }
+
+      // GA4 - gtag
+      if (trackers.includes("gtag") && window.gtag) {
+        let gtagResolve;
+        const gtagPromise = new Promise(resolve => {
+          gtagResolve = resolve;
+        });
+        promises.push(gtagPromise);
+        window.gtag("event", "experiment_viewed", {
+          ...eventParams,
+          event_callback: gtagResolve
+        });
+      }
+
+      // GTM - dataLayer
+      if (trackers.includes("gtm") && window.dataLayer) {
+        let datalayerResolve;
+        const datalayerPromise = new Promise(resolve => {
+          datalayerResolve = resolve;
+        });
+        promises.push(datalayerPromise);
+        window.dataLayer.push({
+          event: "experiment_viewed",
+          ...eventParams,
+          eventCallback: datalayerResolve
+        });
+      }
+
+      // Segment - analytics.js
+      if (trackers.includes("segment") && window.analytics && window.analytics.track) {
+        window.analytics.track("Experiment Viewed", eventParams);
+        const segmentPromise = new Promise(resolve => window.setTimeout(resolve, 300));
+        promises.push(segmentPromise);
+      }
+      await Promise.all(promises);
+    });
+  };
+}
+//# sourceMappingURL=third-party-tracking.js.map

~/.npm-cache/@growthbook/growthbook@1.6.5@@@1/dist/cjs/plugins/third-party-tracking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"third-party-tracking.js","names":["thirdPartyTrackingPlugin","additionalCallback","trackers","window","Error","gb","setTrackingCallback","e","r","promises","eventParams","experiment_id","key","variation_id","push","Promise","resolve","includes","gtag","gtagResolve","gtagPromise","event_callback","dataLayer","datalayerResolve","datalayerPromise","event","eventCallback","analytics","track","segmentPromise","setTimeout","all"],"sources":["../../../src/plugins/third-party-tracking.ts"],"sourcesContent":["import type { TrackingCallback } from \"../types/growthbook\";\nimport type { GrowthBook } from \"../GrowthBook\";\nimport type {\n  GrowthBookClient,\n  UserScopedGrowthBook,\n} from \"../GrowthBookClient\";\n\nexport type Trackers = \"gtag\" | \"gtm\" | \"segment\";\n\nexport function thirdPartyTrackingPlugin({\n  additionalCallback,\n  trackers = [\"gtag\", \"gtm\", \"segment\"],\n}: {\n  additionalCallback?: TrackingCallback;\n  trackers?: Trackers[];\n} = {}) {\n  // Browser only\n  if (typeof window === \"undefined\") {\n    throw new Error(\"thirdPartyTrackingPlugin only works in the browser\");\n  }\n\n  return (gb: GrowthBook | UserScopedGrowthBook | GrowthBookClient) => {\n    gb.setTrackingCallback(async (e, r) => {\n      const promises: Promise<unknown>[] = [];\n      const eventParams = { experiment_id: e.key, variation_id: r.key };\n\n      if (additionalCallback) {\n        promises.push(Promise.resolve(additionalCallback(e, r)));\n      }\n\n      // GA4 - gtag\n      if (trackers.includes(\"gtag\") && window.gtag) {\n        let gtagResolve;\n        const gtagPromise = new Promise((resolve) => {\n          gtagResolve = resolve;\n        });\n        promises.push(gtagPromise);\n        window.gtag(\"event\", \"experiment_viewed\", {\n          ...eventParams,\n          event_callback: gtagResolve,\n        });\n      }\n\n      // GTM - dataLayer\n      if (trackers.includes(\"gtm\") && window.dataLayer) {\n        let datalayerResolve;\n        const datalayerPromise = new Promise((resolve) => {\n          datalayerResolve = resolve;\n        });\n        promises.push(datalayerPromise);\n        window.dataLayer.push({\n          event: \"experiment_viewed\",\n          ...eventParams,\n          eventCallback: datalayerResolve,\n        });\n      }\n\n      // Segment - analytics.js\n      if (\n        trackers.includes(\"segment\") &&\n        window.analytics &&\n        window.analytics.track\n      ) {\n        window.analytics.track(\"Experiment Viewed\", eventParams);\n        const segmentPromise = new Promise((resolve) =>\n          window.setTimeout(resolve, 300),\n        );\n        promises.push(segmentPromise);\n      }\n\n      await Promise.all(promises);\n    });\n  };\n}\n"],"mappings":";;;;;;AASO,SAASA,wBAAwBA,CAAC;EACvCC,kBAAkB;EAClBC,QAAQ,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS;AAItC,CAAC,GAAG,CAAC,CAAC,EAAE;EACN;EACA,IAAI,OAAOC,MAAM,KAAK,WAAW,EAAE;IACjC,MAAM,IAAIC,KAAK,CAAC,oDAAoD,CAAC;EACvE;EAEA,OAAQC,EAAwD,IAAK;IACnEA,EAAE,CAACC,mBAAmB,CAAC,OAAOC,CAAC,EAAEC,CAAC,KAAK;MACrC,MAAMC,QAA4B,GAAG,EAAE;MACvC,MAAMC,WAAW,GAAG;QAAEC,aAAa,EAAEJ,CAAC,CAACK,GAAG;QAAEC,YAAY,EAAEL,CAAC,CAACI;MAAI,CAAC;MAEjE,IAAIX,kBAAkB,EAAE;QACtBQ,QAAQ,CAACK,IAAI,CAACC,OAAO,CAACC,OAAO,CAACf,kBAAkB,CAACM,CAAC,EAAEC,CAAC,CAAC,CAAC,CAAC;MAC1D;;MAEA;MACA,IAAIN,QAAQ,CAACe,QAAQ,CAAC,MAAM,CAAC,IAAId,MAAM,CAACe,IAAI,EAAE;QAC5C,IAAIC,WAAW;QACf,MAAMC,WAAW,GAAG,IAAIL,OAAO,CAAEC,OAAO,IAAK;UAC3CG,WAAW,GAAGH,OAAO;QACvB,CAAC,CAAC;QACFP,QAAQ,CAACK,IAAI,CAACM,WAAW,CAAC;QAC1BjB,MAAM,CAACe,IAAI,CAAC,OAAO,EAAE,mBAAmB,EAAE;UACxC,GAAGR,WAAW;UACdW,cAAc,EAAEF;QAClB,CAAC,CAAC;MACJ;;MAEA;MACA,IAAIjB,QAAQ,CAACe,QAAQ,CAAC,KAAK,CAAC,IAAId,MAAM,CAACmB,SAAS,EAAE;QAChD,IAAIC,gBAAgB;QACpB,MAAMC,gBAAgB,GAAG,IAAIT,OAAO,CAAEC,OAAO,IAAK;UAChDO,gBAAgB,GAAGP,OAAO;QAC5B,CAAC,CAAC;QACFP,QAAQ,CAACK,IAAI,CAACU,gBAAgB,CAAC;QAC/BrB,MAAM,CAACmB,SAAS,CAACR,IAAI,CAAC;UACpBW,KAAK,EAAE,mBAAmB;UAC1B,GAAGf,WAAW;UACdgB,aAAa,EAAEH;QACjB,CAAC,CAAC;MACJ;;MAEA;MACA,IACErB,QAAQ,CAACe,QAAQ,CAAC,SAAS,CAAC,IAC5Bd,MAAM,CAACwB,SAAS,IAChBxB,MAAM,CAACwB,SAAS,CAACC,KAAK,EACtB;QACAzB,MAAM,CAACwB,SAAS,CAACC,KAAK,CAAC,mBAAmB,EAAElB,WAAW,CAAC;QACxD,MAAMmB,cAAc,GAAG,IAAId,OAAO,CAAEC,OAAO,IACzCb,MAAM,CAAC2B,UAAU,CAACd,OAAO,EAAE,GAAG,CAChC,CAAC;QACDP,QAAQ,CAACK,IAAI,CAACe,cAAc,CAAC;MAC/B;MAEA,MAAMd,OAAO,CAACgB,GAAG,CAACtB,QAAQ,CAAC;IAC7B,CAAC,CAAC;EACJ,CAAC;AACH","ignoreList":[]}