apptvty 0.1.5 → 0.2.1

package/dist/chunk-GMQN6656.mjs

@@ -0,0 +1,1096 @@
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.apptvty.com";
+function resolveBaseUrl(config) {
+  const raw = config.baseUrl ?? (typeof process !== "undefined" ? process.env?.APPTVTY_API_URL : void 0) ?? DEFAULT_BASE_URL;
+  return raw.replace(/\/$/, "");
+}
+var ApptvtyClient = class {
+  constructor(config) {
+    this.baseUrl = resolveBaseUrl(config);
+    this.apiKey = config.apiKey;
+    this.siteId = config.siteId;
+    this.debug = config.debug ?? false;
+  }
+  /**
+   * Set the X402 (LSAT) token for subsequent requests.
+   * This is called after the agent has successfully paid an X402 challenge.
+   */
+  setX402Token(macaroon, preimage) {
+    this.x402Token = `LSAT ${macaroon}:${preimage}`;
+  }
+  /**
+   * Send a batch of request log entries to the Apptvty ingestion API.
+   * Called by the logger's auto-flush — not called directly by user code.
+   */
+  async sendLogs(logs) {
+    if (logs.length === 0) return;
+    try {
+      await this.post("/v1/logs/batch", { logs });
+      this.log(`Flushed ${logs.length} log(s)`);
+    } catch (err) {
+      if (err instanceof ApptvtyTrialExpiredError) {
+        console.warn(
+          `
+[apptvty] \u26A0  FREE TRIAL EXPIRED
+[apptvty]    Log in and upgrade to keep receiving agent analytics.
+[apptvty]    Dashboard: ${err.dashboardUrl}
+`
+        );
+        return;
+      }
+      this.warn("Failed to send logs:", err);
+    }
+  }
+  /**
+   * Send a query to the Apptvty backend.
+   * The backend runs RAG against the site's indexed content and,
+   * if ads are enabled for the site, attaches a relevant sponsored ad.
+   *
+   * @throws on non-retryable errors (network errors, 5xx) — callers should catch
+   */
+  async query(req) {
+    const response = await this.post("/v1/query", req);
+    return response;
+  }
+  /**
+   * Get relevant ads for a page (for HTML injection when crawler is detected).
+   * Used by middleware to inject ads into HTML responses.
+   */
+  async getAdsForPage(req) {
+    const response = await this.post("/v1/ads/for-page", req);
+    return response;
+  }
+  /**
+   * Log an ad impression back to Apptvty.
+   *
+   * Called after returning a query response that contains a `sponsored` block.
+   * This is what triggers the billing cycle:
+   *   - Advertiser gets charged (debited from their USDC ad budget)
+   *   - Publisher (the website) gets credited in USDC
+   *
+   * This call is fire-and-forget. The SDK logs a warning on failure
+   * but does not throw — a missed impression log is better than
+   * breaking the query response.
+   */
+  async logImpression(impression) {
+    try {
+      await this.post("/v1/impressions", impression);
+      this.log(`Impression logged: ${impression.impression_id}`);
+    } catch (err) {
+      this.warn("Failed to log impression (billing may be delayed):", err);
+    }
+  }
+  // ─── Analytics (for coding agents) ───────────────────────────────────────────
+  // These allow agents to check activity, logs, and errors without a human.
+  /** Get 30-day traffic overview (requests, AI %, crawlers, queries). */
+  async getSiteStats() {
+    return this.get(`/v1/sites/${this.siteId}/stats`);
+  }
+  /** Get day-by-day stats (default 30 days, max 90). */
+  async getSiteDailyStats(days = 30) {
+    return this.get(`/v1/sites/${this.siteId}/stats/daily`, { days: String(days) });
+  }
+  /** Get recent activity logs (last 48h). */
+  async getRecentActivity(siteId, limit = 50, offset = 0) {
+    return this.get(`/v1/sites/${siteId}/activity`, {
+      limit: String(limit),
+      offset: String(offset)
+    });
+  }
+  /** Get recent agent queries. */
+  async getRecentQueries(siteId, limit = 20, offset = 0) {
+    return this.get(`/v1/sites/${siteId}/queries`, {
+      limit: String(limit),
+      offset: String(offset)
+    });
+  }
+  /** Get crawler breakdown by type (default 30 days). */
+  async getSiteCrawlers(days = 30) {
+    return this.get(`/v1/sites/${this.siteId}/crawlers`, { days: String(days) });
+  }
+  /** Get recent activity feed (last hour, default 50 items, max 200). */
+  async getSiteActivity(limit = 50) {
+    return this.get(`/v1/sites/${this.siteId}/activity`, { limit: String(limit) });
+  }
+  /** Get recent agent queries (default 50, max 200). */
+  async getSiteQueries(limit = 50) {
+    return this.get(`/v1/sites/${this.siteId}/queries`, { limit: String(limit) });
+  }
+  /** Get wallet balance and earnings. */
+  async getSiteWallet() {
+    return this.get(`/v1/sites/${this.siteId}/wallet`);
+  }
+  // ─── Campaign management (for coding agents) ────────────────────────────────
+  //
+  // A coding agent that installed the SDK can create and manage ad campaigns
+  // programmatically — no human dashboard login required.
+  //
+  // Typical agentic advertiser flow:
+  //   1. Check wallet balance:  const w = await client.getSiteWallet()
+  //   2. Fund wallet if needed: send USDC to w.wallet_address on Base chain
+  //   3. Create campaign:       await client.createCampaign({ ... })
+  //   4. Monitor performance:   await client.getCampaign(id)
+  //   5. Adjust or pause:       await client.updateCampaign(id, { status: 'paused' })
+  /**
+   * Create an ad campaign. The campaign goes live immediately once the wallet
+   * has sufficient balance.
+   *
+   * If the wallet balance is too low, throws `ApptvtyInsufficientBalanceError`
+   * which includes deposit instructions so the agent can fund the wallet and retry.
+   *
+   * @example
+   * // Site-based: ad copy derived from your site's crawled content
+   * const campaign = await client.createCampaign({
+   *   name: 'My Kubernetes Blog',
+   *   advertiser_site_id: 'site_abc123',
+   *   keywords: ['kubernetes', 'devops', 'containers'],
+   *   categories: ['technology'],
+   *   bid_per_view_usdc: 0.001,
+   *   daily_budget_usdc: 1.0,
+   *   total_budget_usdc: 20.0,
+   * });
+   *
+   * // Static: manually written ad copy
+   * const campaign = await client.createCampaign({
+   *   name: 'My Blog — Static',
+   *   ad_text: 'Deep dives on Kubernetes, written by practitioners.',
+   *   landing_url: 'https://myblog.com',
+   *   keywords: ['kubernetes', 'devops'],
+   *   categories: ['technology'],
+   *   bid_per_view_usdc: 0.001,
+   *   daily_budget_usdc: 1.0,
+   *   total_budget_usdc: 10.0,
+   * });
+   */
+  async createCampaign(params) {
+    try {
+      return await this.post("/v1/campaigns", params);
+    } catch (err) {
+      if (err instanceof ApptvtyApiError && err.statusCode === 402) {
+        let details;
+        try {
+          const body = JSON.parse(err.body);
+          details = body?.error;
+        } catch {
+        }
+        throw new ApptvtyInsufficientBalanceError(details);
+      }
+      throw err;
+    }
+  }
+  /**
+   * List all campaigns for this account.
+   * Also returns the schema (valid categories, minimum bid) so the agent
+   * knows valid field values without guessing.
+   */
+  async listCampaigns() {
+    return this.get("/v1/campaigns");
+  }
+  /**
+   * Get a single campaign by ID, including current spend and impression count.
+   * `budget_remaining_usdc` tells the agent how much budget is left before
+   * the campaign auto-pauses.
+   */
+  async getCampaign(campaignId) {
+    return this.get(`/v1/campaigns/${campaignId}`);
+  }
+  /**
+   * Partially update a campaign. Only fields present in `params` are changed.
+   *
+   * @example
+   * // Pause a campaign
+   * await client.updateCampaign(id, { status: 'paused' });
+   *
+   * // Increase bid and daily budget
+   * await client.updateCampaign(id, { bid_per_view_usdc: 0.002, daily_budget_usdc: 5.0 });
+   */
+  async updateCampaign(campaignId, params) {
+    return this.patch(`/v1/campaigns/${campaignId}`, params);
+  }
+  /**
+   * Pause a campaign immediately. Equivalent to updateCampaign(id, { status: 'paused' }).
+   * Campaigns are never deleted — billing history is retained.
+   */
+  async pauseCampaign(campaignId) {
+    await this.delete(`/v1/campaigns/${campaignId}`);
+  }
+  /**
+   * Resume a paused campaign.
+   */
+  async resumeCampaign(campaignId) {
+    await this.patch(`/v1/campaigns/${campaignId}`, { status: "active" });
+  }
+  async get(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        Authorization: this.x402Token ?? `Bearer ${this.apiKey}`,
+        "User-Agent": "apptvty-sdk/0.1.0"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new ApptvtyApiError(response.status, path, text);
+    }
+    return response.json();
+  }
+  async patch(path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: {
+        "Authorization": this.x402Token ?? `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": "apptvty-sdk/0.1.0"
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new ApptvtyApiError(response.status, path, text);
+    }
+    return response.json();
+  }
+  async delete(path) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: {
+        "Authorization": this.x402Token ?? `Bearer ${this.apiKey}`,
+        "User-Agent": "apptvty-sdk/0.1.0"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new ApptvtyApiError(response.status, path, text);
+    }
+  }
+  /**
+   * Settle an X402 challenge from the site's own USDC wallet balance.
+   * Called automatically when `post()` receives a 402 with an X402 header.
+   * Returns the preimage on success, or throws if the wallet balance is too low.
+   */
+  async payX402Challenge(macaroon) {
+    const url = `${this.baseUrl}/v1/x402/pay`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": "apptvty-sdk/0.1.0"
+      },
+      body: JSON.stringify({ macaroon }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    const text = await response.text().catch(() => "");
+    if (!response.ok) {
+      let details;
+      try {
+        details = JSON.parse(text)?.error?.details;
+      } catch {
+      }
+      throw new ApptvtyInsufficientBalanceError(details);
+    }
+    const json = JSON.parse(text);
+    return json.preimage;
+  }
+  async post(path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": this.x402Token ?? `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": "apptvty-sdk/0.1.0"
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      if (response.status === 402) {
+        const authHeader = response.headers.get("WWW-Authenticate");
+        if (authHeader?.includes("X402") || authHeader?.includes("LSAT")) {
+          const macaroon = authHeader.match(/macaroon="([^"]+)"/)?.[1] || "";
+          const preimage = await this.payX402Challenge(macaroon);
+          this.setX402Token(macaroon, preimage);
+          this.log("X402 challenge auto-paid from wallet, retrying request");
+          return this.post(path, body);
+        }
+        let dashboardUrl = "https://dashboard.apptvty.com/login";
+        try {
+          const json = JSON.parse(text);
+          dashboardUrl = json?.error?.details?.dashboard_url ?? dashboardUrl;
+        } catch {
+        }
+        throw new ApptvtyTrialExpiredError(dashboardUrl);
+      }
+      throw new ApptvtyApiError(response.status, path, text);
+    }
+    return response.json();
+  }
+  log(...args) {
+    if (this.debug) console.log("[apptvty]", ...args);
+  }
+  warn(...args) {
+    if (this.debug) console.warn("[apptvty]", ...args);
+  }
+};
+var ApptvtyApiError = class extends Error {
+  constructor(statusCode, path, body) {
+    super(`Apptvty API error ${statusCode} at ${path}: ${body}`);
+    this.statusCode = statusCode;
+    this.path = path;
+    this.body = body;
+    this.name = "ApptvtyApiError";
+  }
+};
+var ApptvtyTrialExpiredError = class extends Error {
+  constructor(dashboardUrl) {
+    super(`Apptvty free trial has expired. Log in to continue: ${dashboardUrl}`);
+    this.dashboardUrl = dashboardUrl;
+    this.name = "ApptvtyTrialExpiredError";
+  }
+};
+var ApptvtyInsufficientBalanceError = class extends Error {
+  constructor(details) {
+    const shortfall = details?.shortfall_usdc ?? "?";
+    super(
+      `Wallet balance too low to create campaign. Send ${shortfall} USDC to ${details?.deposit?.address ?? "your wallet"} on Base and retry.`
+    );
+    this.details = details;
+    this.name = "ApptvtyInsufficientBalanceError";
+  }
+};
+
+// src/logger.ts
+var RequestLogger = class {
+  constructor(client, config) {
+    this.client = client;
+    this.queue = [];
+    this.timer = null;
+    this.flushing = false;
+    this.batchSize = config.batchSize ?? 50;
+    this.debug = config.debug ?? false;
+    const interval = config.flushInterval ?? 5e3;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, interval);
+    if (this.timer && typeof this.timer.unref === "function") {
+      this.timer.unref();
+    }
+    if (typeof process !== "undefined" && typeof process.once === "function") {
+      const handleExit = () => {
+        void this.flushSync();
+      };
+      try {
+        process.once("SIGTERM", handleExit);
+        process.once("SIGINT", handleExit);
+        process.once("beforeExit", handleExit);
+      } catch {
+      }
+    }
+  }
+  /** Enqueue a single log entry. Non-blocking. */
+  enqueue(entry) {
+    this.queue.push(entry);
+    if (this.queue.length >= this.batchSize) {
+      void this.flush();
+    }
+  }
+  /** Flush the current queue to the API. */
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    const batch = this.queue.splice(0, this.batchSize);
+    try {
+      await this.client.sendLogs(batch);
+    } catch {
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /**
+   * Synchronous-ish flush for process shutdown.
+   * Fires the fetch and doesn't await to avoid blocking exit handlers.
+   */
+  flushSync() {
+    if (this.queue.length === 0) return;
+    const batch = this.queue.splice(0);
+    void this.client.sendLogs(batch);
+  }
+  /** Stop the interval timer. Call when you want to fully tear down the SDK. */
+  destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    void this.flush();
+  }
+  log(...args) {
+    if (this.debug) console.log("[apptvty:logger]", ...args);
+  }
+};
+function getClientIp(headers) {
+  const forwarded = headers["x-forwarded-for"];
+  if (forwarded) {
+    const first = Array.isArray(forwarded) ? forwarded[0] : forwarded;
+    return first.split(",")[0].trim();
+  }
+  return headers["x-real-ip"] ?? "unknown";
+}
+
+// src/crawler.ts
+var KNOWN_CRAWLERS = [
+  // OpenAI
+  { name: "GPTBot", organization: "OpenAI", patterns: [/GPTBot/i, /ChatGPT-User/i] },
+  { name: "OpenAI-SearchBot", organization: "OpenAI", patterns: [/OpenAI-SearchBot/i] },
+  // Anthropic
+  { name: "ClaudeBot", organization: "Anthropic", patterns: [/ClaudeBot/i, /Claude-Web/i, /Anthropic-AI/i] },
+  // Google
+  { name: "Google-Extended", organization: "Google AI", patterns: [/Google-Extended/i] },
+  { name: "GoogleOther", organization: "Google AI", patterns: [/GoogleOther/i] },
+  { name: "Googlebot", organization: "Google", patterns: [/Googlebot/i] },
+  // Microsoft
+  { name: "Bingbot", organization: "Microsoft", patterns: [/bingbot/i, /BingPreview/i] },
+  // Perplexity
+  { name: "PerplexityBot", organization: "Perplexity", patterns: [/PerplexityBot/i] },
+  // You.com
+  { name: "YouBot", organization: "You.com", patterns: [/YouBot/i] },
+  // Meta
+  { name: "Meta-ExternalAgent", organization: "Meta", patterns: [/Meta-ExternalAgent/i] },
+  { name: "FacebookBot", organization: "Meta", patterns: [/facebookexternalhit/i, /FacebookBot/i] },
+  // Apple
+  { name: "AppleBot", organization: "Apple", patterns: [/Applebot/i] },
+  // Twitter/X
+  { name: "TwitterBot", organization: "Twitter/X", patterns: [/Twitterbot/i] },
+  // LinkedIn
+  { name: "LinkedInBot", organization: "LinkedIn", patterns: [/LinkedInBot/i] },
+  // DuckDuckGo
+  { name: "DuckDuckBot", organization: "DuckDuckGo", patterns: [/DuckDuckBot/i] },
+  // Cohere
+  { name: "Cohere-AI", organization: "Cohere", patterns: [/Cohere-AI/i, /cohere-ai/i] },
+  // Allen Institute
+  { name: "AI2Bot", organization: "Allen Institute for AI", patterns: [/AI2Bot/i] },
+  // Mistral
+  { name: "MistralBot", organization: "Mistral AI", patterns: [/MistralBot/i] }
+];
+var AI_PATTERN_MATCHES = [
+  [/openai/i, 0.9],
+  [/anthropic/i, 0.9],
+  [/gpt|chatgpt/i, 0.85],
+  [/claude/i, 0.85],
+  [/perplexity/i, 0.85],
+  [/llm|language[- ]model/i, 0.75],
+  [/bot.*ai|ai.*bot/i, 0.75],
+  [/search.*ai|ai.*search/i, 0.7]
+];
+var HUMAN_SIGNALS = [
+  /Mozilla\/5\.0.*\(Windows NT.*\) AppleWebKit.*Chrome.*Safari/i,
+  /Mozilla\/5\.0.*\(Macintosh.*\) AppleWebKit.*Version.*Safari/i
+];
+function detectCrawler(userAgent) {
+  if (!userAgent || userAgent.length < 4) {
+    return { isAi: false, name: null, organization: null, confidence: 0.3, detectionMethod: "heuristic" };
+  }
+  for (const crawler of KNOWN_CRAWLERS) {
+    for (const pattern of crawler.patterns) {
+      if (pattern.test(userAgent)) {
+        return {
+          isAi: true,
+          name: crawler.name,
+          organization: crawler.organization,
+          confidence: 0.95,
+          detectionMethod: "exact_match"
+        };
+      }
+    }
+  }
+  for (const pattern of HUMAN_SIGNALS) {
+    if (pattern.test(userAgent)) {
+      return { isAi: false, name: null, organization: null, confidence: 0.85, detectionMethod: "heuristic" };
+    }
+  }
+  for (const [pattern, confidence] of AI_PATTERN_MATCHES) {
+    if (pattern.test(userAgent)) {
+      return {
+        isAi: true,
+        name: extractBotName(userAgent),
+        organization: null,
+        confidence,
+        detectionMethod: "pattern_match"
+      };
+    }
+  }
+  let score = 0;
+  if (/bot|crawler|spider|scraper/i.test(userAgent)) score += 0.4;
+  if (/python-requests|curl\/|wget\/|scrapy|go-http-client/i.test(userAgent)) score += 0.3;
+  if (!userAgent.includes("Mozilla")) score += 0.2;
+  if (userAgent.length < 20) score += 0.2;
+  if (score >= 0.5) {
+    return {
+      isAi: false,
+      // Generic bot — not classified as AI
+      name: "unknown_bot",
+      organization: null,
+      confidence: Math.min(score, 0.8),
+      detectionMethod: "heuristic"
+    };
+  }
+  return { isAi: false, name: null, organization: null, confidence: 0.1, detectionMethod: "none" };
+}
+function extractBotName(userAgent) {
+  const parts = userAgent.split(/[\s/;(]+/);
+  for (const part of parts) {
+    if (/bot|agent|crawler|ai/i.test(part) && part.length > 2) {
+      return part.replace(/[^a-zA-Z0-9-_]/g, "");
+    }
+  }
+  return "unknown_ai_bot";
+}
+function getKnownCrawlerNames() {
+  return KNOWN_CRAWLERS.map((c) => c.name);
+}
+var SCRAPER_SERVICES = [
+  // Jina AI Reader — r.jina.ai/URL — converts any page to clean Markdown
+  { name: "JinaReader", patterns: [/JinaReader/i] },
+  // Cloudflare Browser Rendering /crawl endpoint (open beta, announced March 2026)
+  { name: "Cloudflare-BrowserRendering", patterns: [/CloudflareBrowserRenderingCrawler/i] },
+  // FireCrawl — LLM-ready content extraction service
+  { name: "FireCrawl", patterns: [/FireCrawlAgent/i, /firecrawl/i] },
+  // Apify web scraping platform
+  { name: "Apify", patterns: [/ApifyBot/i] }
+];
+function detectScraperService(userAgent) {
+  if (!userAgent) return { isScraperService: false, name: null };
+  for (const service of SCRAPER_SERVICES) {
+    for (const pattern of service.patterns) {
+      if (pattern.test(userAgent)) {
+        return { isScraperService: true, name: service.name };
+      }
+    }
+  }
+  return { isScraperService: false, name: null };
+}
+
+// src/query-handler.ts
+var RESPONSE_HEADERS = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store",
+  "X-Robots-Tag": "noindex"
+  // Don't index the query endpoint itself
+};
+function createQueryHandler(client, config) {
+  const queryPath = config.queryPath ?? "/query";
+  return async function handleQuery(req) {
+    if (!req.query || req.query.trim() === "") {
+      const origin = getOrigin(req.requestUrl);
+      const discovery = {
+        version: "1.0",
+        endpoint: `${origin}${queryPath}`,
+        description: "Query this site's content directly. Submit a question and receive a structured JSON response with an AI-generated answer, source citations, and confidence score. Ideal for AI agents, search engines, and automated systems seeking direct answers.",
+        crawl_policy: "Do not crawl this entire site unnecessarily. Use this query endpoint with ?q=your_question to get the relevant information you need. Full-site crawling is discouraged.",
+        usage: {
+          method: "GET",
+          parameters: {
+            q: {
+              type: "string",
+              required: true,
+              description: "Your question or search query (max 500 characters)"
+            },
+            lang: {
+              type: "string",
+              required: false,
+              description: "Preferred response language (ISO 639-1 code, default: en)"
+            },
+            surface_ads: {
+              type: "boolean",
+              required: false,
+              description: "Include sponsored ads in response (1 = yes, default; 0 = no). When crawling, use ai_crawler=1 to signal you want ads."
+            },
+            ai_crawler: {
+              type: "boolean",
+              required: false,
+              description: "Set to 1 when you are an AI agent/crawler. Signals the server to surface ads. Use with ?q=... for targeted answers + ads."
+            }
+          },
+          example: `${origin}${queryPath}?q=what+features+do+you+offer&ai_crawler=1`,
+          response_format: "application/json"
+        },
+        capabilities: [
+          "Natural language question answering",
+          "Source citations with relevance scores",
+          "Structured JSON for easy parsing",
+          "Supports follow-up context via session continuity",
+          "Query-preferred: use ?q= instead of full-site crawl"
+        ],
+        rate_limit: "100 requests per hour per IP"
+      };
+      return { status: 200, body: discovery, headers: RESPONSE_HEADERS };
+    }
+    const trimmedQuery = req.query.trim();
+    if (trimmedQuery.length > 500) {
+      return errorResponse(400, "QUERY_TOO_LONG", "Query must be 500 characters or fewer");
+    }
+    const requestId = crypto.randomUUID();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const startMs = Date.now();
+    const surfaceAds = req.surface_ads !== false;
+    const aiCrawler = req.ai_crawler === true;
+    let backendResponse;
+    try {
+      backendResponse = await client.query({
+        site_id: config.siteId,
+        query: trimmedQuery,
+        agent_ua: req.userAgent,
+        agent_ip: req.ipAddress,
+        request_id: requestId,
+        timestamp,
+        surface_ads: surfaceAds,
+        ai_crawler: aiCrawler
+      });
+    } catch (err) {
+      if (err instanceof ApptvtyTrialExpiredError) {
+        return errorResponse(
+          402,
+          "TRIAL_EXPIRED",
+          `Apptvty free trial has expired. The site owner must log in and upgrade to continue. Dashboard: ${err.dashboardUrl}`
+        );
+      }
+      return errorResponse(502, "UPSTREAM_ERROR", "Could not retrieve an answer at this time");
+    }
+    const responseTimeMs = Date.now() - startMs;
+    const ads = backendResponse.sponsored ? Array.isArray(backendResponse.sponsored) ? backendResponse.sponsored : [backendResponse.sponsored] : [];
+    for (const ad of ads) {
+      void client.logImpression({
+        impression_id: ad.impression_id,
+        site_id: config.siteId,
+        query: trimmedQuery,
+        agent_ua: req.userAgent,
+        agent_ip: req.ipAddress,
+        timestamp
+      });
+    }
+    const agentResponse = {
+      success: true,
+      version: "1.0",
+      query: trimmedQuery,
+      answer: backendResponse.answer,
+      sources: backendResponse.sources,
+      confidence: backendResponse.confidence,
+      ...backendResponse.sponsored && { sponsored: backendResponse.sponsored },
+      metadata: {
+        request_id: requestId,
+        response_time_ms: responseTimeMs,
+        tokens_used: backendResponse.tokens_used,
+        site_id: config.siteId,
+        timestamp
+      }
+    };
+    return { status: 200, body: agentResponse, headers: RESPONSE_HEADERS };
+  };
+}
+function errorResponse(status, code, message) {
+  const body = {
+    success: false,
+    error: {
+      code,
+      message,
+      request_id: crypto.randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  return { status, body, headers: RESPONSE_HEADERS };
+}
+function getOrigin(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.origin;
+  } catch {
+    return "";
+  }
+}
+
+// src/dashboard-handler.ts
+function createDashboardHandler(client, config) {
+  return async function handleDashboard(req) {
+    const { path, method, authHeader } = req;
+    if (config.dashboardSecret) {
+      const url = new URL(path, "http://localhost");
+      const secretParam = url.searchParams.get("secret");
+      const bearerToken = authHeader?.startsWith("Bearer ") ? authHeader.substring(7) : null;
+      const isAuthorized = secretParam === config.dashboardSecret || bearerToken === config.dashboardSecret;
+      if (!isAuthorized) {
+        return jsonResponse(401, {
+          error: "Unauthorized",
+          message: "Dashboard access requires a valid secret. Please set APPTVTY_DASHBOARD_SECRET."
+        });
+      }
+    }
+    if (path.includes("/api/overview")) {
+      const data = await client.getSiteStats();
+      return jsonResponse(200, data);
+    }
+    if (path.endsWith("/api/activity")) {
+      const url = new URL(path, "http://localhost");
+      const limit = parseInt(url.searchParams.get("limit") || "50");
+      const offset = parseInt(url.searchParams.get("offset") || "0");
+      const data = await client.getRecentActivity(config.siteId, limit, offset);
+      return jsonResponse(200, data);
+    }
+    if (path.endsWith("/api/queries")) {
+      const url = new URL(path, "http://localhost");
+      const limit = parseInt(url.searchParams.get("limit") || "20");
+      const offset = parseInt(url.searchParams.get("offset") || "0");
+      const data = await client.getRecentQueries(config.siteId, limit, offset);
+      return jsonResponse(200, data);
+    }
+    if (path.endsWith("/api/stats")) {
+      const data = await client.getSiteDailyStats();
+      return jsonResponse(200, data);
+    }
+    const html = getDashboardHtml(config);
+    return {
+      status: 200,
+      body: html,
+      headers: { "Content-Type": "text/html" }
+    };
+  };
+}
+function jsonResponse(status, data) {
+  return {
+    status,
+    body: JSON.stringify(data),
+    headers: { "Content-Type": "application/json" }
+  };
+}
+function getDashboardHtml(config) {
+  return `
+<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Apptvty Logs \u2014 ${config.siteId}</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://unpkg.com/lucide@latest"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+        body { font-family: 'Inter', sans-serif; background-color: #09090b; color: #fafafa; }
+        .glass { background: rgba(24, 24, 27, 0.8); backdrop-filter: blur(12px); border: 1px solid rgba(39, 39, 42, 1); }
+        .gradient-text { background: linear-gradient(to right, #60a5fa, #a855f7); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+    </style>
+</head>
+<body class="p-6">
+    <div id="app" class="max-w-7xl mx-auto space-y-6">
+        <!-- Header -->
+        <header class="flex justify-between items-center mb-8">
+            <div>
+                <h1 class="text-3xl font-bold gradient-text">Activity Logs</h1>
+                <p class="text-zinc-400">Real-time agentic insights for ${config.siteId}</p>
+            </div>
+            <div class="flex items-center gap-3">
+                <span class="flex h-2 w-2 rounded-full bg-green-500 animate-pulse"></span>
+                <span class="text-sm font-medium text-zinc-300">Live Connection</span>
+            </div>
+        </header>
+
+        <!-- Stats Grid -->
+        <div class="grid grid-cols-1 md:grid-cols-4 gap-4" id="stats-grid">
+            <div class="glass p-5 rounded-2xl animate-pulse h-24"></div>
+            <div class="glass p-5 rounded-2xl animate-pulse h-24"></div>
+            <div class="glass p-5 rounded-2xl animate-pulse h-24"></div>
+            <div class="glass p-5 rounded-2xl animate-pulse h-24"></div>
+        </div>
+
+        <!-- Main Content -->
+        <div class="grid grid-cols-1 lg:grid-cols-3 gap-6">
+            <!-- Traffic Chart -->
+            <div class="lg:col-span-2 glass p-6 rounded-2xl">
+                <h2 class="text-lg font-semibold mb-4">Traffic Overview</h2>
+                <div class="h-[300px]">
+                    <canvas id="trafficChart"></canvas>
+                </div>
+            </div>
+
+            <!-- Recent Queries -->
+            <div class="glass p-6 rounded-2xl flex flex-col h-[400px]">
+                <div class="flex justify-between items-center mb-4">
+                    <h2 class="text-lg font-semibold">Agent Queries</h2>
+                    <button id="load-more-queries" class="text-xs text-blue-400 hover:text-blue-300 transition-colors">Load More</button>
+                </div>
+                <div id="queries-list" class="flex-1 overflow-y-auto space-y-3 custom-scrollbar">
+                    <div class="text-zinc-500 text-sm italic">Loading queries...</div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Real-time Activity Table -->
+        <div class="glass p-6 rounded-2xl overflow-hidden">
+            <div class="flex justify-between items-center mb-4">
+                <h2 class="text-lg font-semibold">Real-time Activity</h2>
+                <button id="load-more-activity" class="text-sm px-3 py-1 bg-zinc-800 hover:bg-zinc-700 rounded-lg text-zinc-300 transition-colors">Load More</button>
+            </div>
+            <div class="overflow-x-auto">
+                <table class="w-full text-left">
+                    <thead>
+                        <tr class="text-zinc-500 text-sm border-b border-zinc-800">
+                            <th class="pb-3 pr-4">Timestamp</th>
+                            <th class="pb-3 pr-4">Method</th>
+                            <th class="pb-3 pr-4">Path</th>
+                            <th class="pb-3 pr-4">Agent</th>
+                            <th class="pb-3">Status</th>
+                        </tr>
+                    </thead>
+                    <tbody id="activity-body" class="text-sm">
+                        <tr><td colspan="5" class="pt-4 text-zinc-500 italic">Connecting to activity stream...</td></tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const API_BASE = window.location.pathname.replace(//$/, '');
+        let queryOffset = 0;
+        let activityOffset = 0;
+        const LIMIT_QUERIES = 20;
+        const LIMIT_ACTIVITY = 50;
+
+        async function fetchData() {
+            try {
+                // Initial load or refresh (offset 0 resets)
+                const [overview, stats] = await Promise.all([
+                    fetch(\`\${API_BASE}/api/overview\`).then(r => r.json()),
+                    fetch(\`\${API_BASE}/api/stats\`).then(r => r.json())
+                ]);
+
+                updateStats(overview);
+                initChart(stats);
+
+                // Fetch first pages if empty
+                if (queryOffset === 0) fetchQueries(true);
+                if (activityOffset === 0) fetchActivity(true);
+            } catch (err) {
+                console.error('Failed to fetch dashboard data:', err);
+            }
+        }
+
+        async function fetchQueries(replace = false) {
+            try {
+                const data = await fetch(\`\${API_BASE}/api/queries?limit=\${LIMIT_QUERIES}&offset=\${queryOffset}\`).then(r => r.json());
+                updateQueries(data, replace);
+            } catch (e) { console.error('Queries error:', e); }
+        }
+
+        async function fetchActivity(replace = false) {
+            try {
+                const data = await fetch(\`\${API_BASE}/api/activity?limit=\${LIMIT_ACTIVITY}&offset=\${activityOffset}\`).then(r => r.json());
+                updateActivity(data, replace);
+            } catch (e) { console.error('Activity error:', e); }
+        }
+
+        function updateStats(data) {
+            const grid = document.getElementById('stats-grid');
+            grid.innerHTML = \`
+                <div class="glass p-5 rounded-2xl">
+                    <p class="text-zinc-400 text-xs font-medium uppercase tracking-wider mb-1">Total Requests</p>
+                    <p class="text-2xl font-bold">\${data.total_requests_30d.toLocaleString()}</p>
+                </div>
+                <div class="glass p-5 rounded-2xl border-l-4 border-blue-500">
+                    <p class="text-zinc-400 text-xs font-medium uppercase tracking-wider mb-1">AI Requests</p>
+                    <p class="text-2xl font-bold">\${data.ai_requests_30d.toLocaleString()}</p>
+                </div>
+                <div class="glass p-5 rounded-2xl">
+                    <p class="text-zinc-400 text-xs font-medium uppercase tracking-wider mb-1">AI Percentage</p>
+                    <p class="text-2xl font-bold text-blue-400">\${data.ai_percentage.toFixed(1)}%</p>
+                </div>
+                <div class="glass p-5 rounded-2xl">
+                    <p class="text-zinc-400 text-xs font-medium uppercase tracking-wider mb-1">Health Status</p>
+                    <p class="text-2xl font-bold text-green-400">Optimal</p>
+                </div>
+            \`;
+        }
+
+        function updateQueries(data, replace) {
+            const list = document.getElementById('queries-list');
+            const items = Array.isArray(data) ? data : (data.queries || []);
+            const rows = items.map(q => \`
+                <div class="p-3 bg-zinc-900/50 rounded-xl border border-zinc-800 hover:border-zinc-700 transition-colors">
+                    <p class="text-sm font-medium text-zinc-200">\${q.question || q.query}</p>
+                    <div class="mt-2 flex justify-between items-center text-[10px] text-zinc-500">
+                        <span class="flex items-center gap-1">
+                            <i data-lucide="clock" class="w-3 h-3"></i>
+                            \${new Date(q.timestamp).toLocaleString()}
+                        </span>
+                        <span class="px-2 py-0.5 rounded-full bg-blue-500/10 text-blue-400 border border-blue-500/20">
+                            Agent Match
+                        </span>
+                    </div>
+                </div>
+            \`).join('');
+
+            if (replace) list.innerHTML = rows || '<div class="text-zinc-600 text-sm">No recent queries.</div>';
+            else list.insertAdjacentHTML('beforeend', rows);
+            lucide.createIcons();
+        }
+
+        function updateActivity(data, replace) {
+            const body = document.getElementById('activity-body');
+            const items = Array.isArray(data) ? data : (data.activity || []);
+            const rows = items.map(r => \`
+                <tr class="border-b border-zinc-800/50 hover:bg-zinc-800/20 transition-colors">
+                    <td class="py-3 pr-4 text-zinc-400 text-xs">\${new Date(r.timestamp || r.created_at).toLocaleTimeString()}</td>
+                    <td class="py-3 pr-4 font-mono text-[10px] tracking-tight text-blue-400">\${r.method}</td>
+                    <td class="py-3 pr-4 text-zinc-300 max-w-xs truncate">\${r.path}</td>
+                    <td class="py-3 pr-4 text-zinc-500">\${r.crawler_type || 'Human'}</td>
+                    <td class="py-3">
+                        <span class="px-2 py-0.5 rounded-md \${r.status_code >= 400 ? 'bg-red-500/10 text-red-400' : 'bg-green-500/10 text-green-400'} text-[10px] font-medium border border-current/20">
+                            \${r.status_code || 200}
+                        </span>
+                    </td>
+                </tr>
+            \`).join('');
+
+            if (replace) body.innerHTML = rows || '<tr><td colspan="5" class="py-4 text-center text-zinc-600">No activity.</td></tr>';
+            else body.insertAdjacentHTML('beforeend', rows);
+        }
+
+        function initChart(stats) {
+            const canvas = document.getElementById('trafficChart');
+            if (window.myChart) window.myChart.destroy();
+            const ctx = canvas.getContext('2d');
+            window.myChart = new Chart(ctx, {
+                type: 'line',
+                data: {
+                    labels: stats.map(s => s.date.split('-').slice(1).join('/')),
+                    datasets: [
+                        {
+                            label: 'AI Requests',
+                            data: stats.map(s => s.ai_requests),
+                            borderColor: '#3b82f6',
+                            backgroundColor: 'rgba(59, 130, 246, 0.1)',
+                            fill: true,
+                            tension: 0.4
+                        },
+                        {
+                            label: 'Total Requests',
+                            data: stats.map(s => s.total_requests),
+                            borderColor: '#8b5cf6',
+                            backgroundColor: 'rgba(139, 92, 246, 0.1)',
+                            fill: true,
+                            tension: 0.4
+                        }
+                    ]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    plugins: { legend: { display: false }, tooltip: { mode: 'index', intersect: false } },
+                    scales: {
+                        y: { beginAtZero: true, grid: { color: 'rgba(39, 39, 42, 0.5)' }, ticks: { color: '#71717a' } },
+                        x: { grid: { display: false }, ticks: { color: '#71717a' } }
+                    }
+                }
+            });
+        }
+
+        document.getElementById('load-more-queries').onclick = () => {
+            queryOffset += LIMIT_QUERIES;
+            fetchQueries(false);
+        };
+
+        document.getElementById('load-more-activity').onclick = () => {
+            activityOffset += LIMIT_ACTIVITY;
+            fetchActivity(false);
+        };
+
+        fetchData();
+        setInterval(fetchData, 30000); // Polling for updates (stats only)
+    </script>
+</body>
+</html>
+  `;
+}
+
+// src/ad-injection.ts
+var AD_INJECTION_MARKER = "<!-- apptvty-sponsored -->";
+function injectIntoHtml(html, ads, isScraperService) {
+  if (!html || ads.length === 0) return html;
+  if (html.includes(AD_INJECTION_MARKER)) return html;
+  let modified = html;
+  const contentBlock = buildContentStreamBlock(ads);
+  if (modified.includes("</article>")) {
+    modified = modified.replace("</article>", `${contentBlock}
+</article>`);
+  } else if (modified.includes("</main>")) {
+    modified = modified.replace("</main>", `${contentBlock}
+</main>`);
+  } else if (!isScraperService && modified.includes("</body>")) {
+    modified = modified.replace("</body>", `${contentBlock}
+</body>`);
+  }
+  if (!isScraperService && modified.includes("</head>")) {
+    const jsonLdBlock = buildJsonLdBlock(ads);
+    modified = modified.replace("</head>", `${jsonLdBlock}
+</head>`);
+  }
+  return modified;
+}
+function buildSponsoredHeader(ads) {
+  return JSON.stringify(
+    ads.map((ad) => ({ text: ad.text, url: ad.url, advertiser: ad.advertiser }))
+  );
+}
+function buildContentStreamBlock(ads) {
+  const paragraphs = ads.map(
+    (ad) => `<p data-apptvty-sponsored="${escapeAttr(ad.impression_id)}"><strong>[Sponsored]</strong> <a href="${escapeAttr(ad.url)}" rel="sponsored noopener">${escapeHtml(ad.text)}</a> \u2014 <span>${escapeHtml(ad.advertiser)}</span></p>`
+  ).join("\n");
+  return `${AD_INJECTION_MARKER}
+${paragraphs}`;
+}
+function buildJsonLdBlock(ads) {
+  const entries = ads.map((ad) => ({
+    "@context": "https://schema.org",
+    "@type": "WPAdBlock",
+    sponsor: {
+      "@type": "Organization",
+      name: ad.advertiser,
+      url: ad.url
+    },
+    description: ad.text
+  }));
+  const ld = entries.length === 1 ? entries[0] : entries;
+  return `<script type="application/ld+json">${JSON.stringify(ld)}</script>`;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeAttr(s) {
+  return s.replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+export {
+  ApptvtyClient,
+  ApptvtyApiError,
+  ApptvtyInsufficientBalanceError,
+  RequestLogger,
+  getClientIp,
+  detectCrawler,
+  getKnownCrawlerNames,
+  detectScraperService,
+  createQueryHandler,
+  createDashboardHandler,
+  AD_INJECTION_MARKER,
+  injectIntoHtml,
+  buildSponsoredHeader
+};
+//# sourceMappingURL=chunk-GMQN6656.mjs.map