@yak-io/javascript 0.1.0

package/dist/client.js

@@ -0,0 +1,504 @@
+import { extractPageContext, debounce } from "./page-context.js";
+import { EMBED_PROTOCOL_VERSION } from "./version.js";
+import { logger } from "./logger.js";
+/**
+ * Determines the iframe origin based on the current environment.
+ * - Internal dev (localhost on *.yak.* domain) -> http://localhost:3001
+ * - Dev stage (*.yak.supply) -> https://chat.yak.supply
+ * - Everything else (including external developers on localhost) -> https://chat.yak.io
+ */
+function getIframeOriginForEnvironment() {
+    if (typeof window !== "undefined") {
+        const hostname = window.location.hostname;
+        // Check for dev stage via hostname pattern (e.g., *.yak.supply)
+        if (hostname.endsWith(".yak.supply") || hostname === "yak.supply") {
+            return "https://chat.yak.supply";
+        }
+        // Internal development only: localhost when running on a yak domain locally
+        // This is detected by checking if we're on localhost AND the referrer/opener is a yak domain
+        // For simplicity, we check if running on localhost with a specific dev flag
+        if ((hostname === "localhost" || hostname === "127.0.0.1") &&
+            typeof window.__YAK_INTERNAL_DEV__ !== "undefined") {
+            return "http://localhost:3001";
+        }
+    }
+    // Default to production - external developers on localhost will connect to prod
+    return "https://chat.yak.io";
+}
+export class YakClient {
+    config;
+    iframeWindow = null;
+    isWidgetOpen = false;
+    readyTarget = null;
+    unexpectedOriginLogged = false;
+    lastUrl = " ";
+    debouncedSendContext;
+    observer = null;
+    constructor(config) {
+        this.config = config;
+        this.debouncedSendContext = debounce(() => {
+            logger.debug("DOM mutation detected, sending page context");
+            this.sendPageContext();
+        }, 2000);
+    }
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        if (this.readyTarget && this.config.chatConfig) {
+            this.sendConfigToIframe(this.readyTarget.window, this.readyTarget.origin);
+        }
+    }
+    /**
+     * Get the iframe origin URL (base URL for the chat widget)
+     * This is computed each time to support setting __YAK_INTERNAL_DEV__ after page load.
+     */
+    getIframeOrigin() {
+        return getIframeOriginForEnvironment();
+    }
+    /**
+     * Get the full iframe embed URL for the chatbot
+     *
+     * @example
+     * ```ts
+     * const client = new YakClient({ appId: "my-app" });
+     * const iframeSrc = client.getEmbedUrl();
+     * // Returns: "https://chat.yak.io/embed/v1/my-app"
+     * ```
+     */
+    getEmbedUrl() {
+        const origin = this.getIframeOrigin();
+        const baseUrl = `${origin}/embed/v${EMBED_PROTOCOL_VERSION}/${encodeURIComponent(this.config.appId)}`;
+        // Build URL params for theme colors to avoid flash of default colors
+        const params = new URLSearchParams();
+        const theme = this.config.theme;
+        if (theme?.colorMode && theme.colorMode !== "system") {
+            params.set("colorMode", theme.colorMode);
+        }
+        // Light mode colors
+        if (theme?.light?.background) {
+            params.set("lightBg", theme.light.background);
+        }
+        if (theme?.light?.border) {
+            params.set("lightBorder", theme.light.border);
+        }
+        if (theme?.light?.messageBackground) {
+            params.set("lightMessageBg", theme.light.messageBackground);
+        }
+        if (theme?.light?.placeholderColor) {
+            params.set("lightPlaceholder", theme.light.placeholderColor);
+        }
+        if (theme?.light?.submitButtonColor) {
+            params.set("lightSubmitBtn", theme.light.submitButtonColor);
+        }
+        if (theme?.light?.submitButtonTextColor) {
+            params.set("lightSubmitBtnText", theme.light.submitButtonTextColor);
+        }
+        if (theme?.light?.headerIconColor) {
+            params.set("lightHeaderIcon", theme.light.headerIconColor);
+        }
+        // Dark mode colors
+        if (theme?.dark?.background) {
+            params.set("darkBg", theme.dark.background);
+        }
+        if (theme?.dark?.border) {
+            params.set("darkBorder", theme.dark.border);
+        }
+        if (theme?.dark?.messageBackground) {
+            params.set("darkMessageBg", theme.dark.messageBackground);
+        }
+        if (theme?.dark?.placeholderColor) {
+            params.set("darkPlaceholder", theme.dark.placeholderColor);
+        }
+        if (theme?.dark?.submitButtonColor) {
+            params.set("darkSubmitBtn", theme.dark.submitButtonColor);
+        }
+        if (theme?.dark?.submitButtonTextColor) {
+            params.set("darkSubmitBtnText", theme.dark.submitButtonTextColor);
+        }
+        if (theme?.dark?.headerIconColor) {
+            params.set("darkHeaderIcon", theme.dark.headerIconColor);
+        }
+        const queryString = params.toString();
+        return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+    }
+    /**
+     * Get the app ID
+     */
+    getAppId() {
+        return this.config.appId;
+    }
+    /**
+     * Get the current theme configuration
+     */
+    getTheme() {
+        return this.config.theme;
+    }
+    /**
+     * Send a prompt message to the chatbot iframe
+     * Note: The iframe must be ready to receive messages (onReady callback must have fired)
+     *
+     * @example
+     * ```ts
+     * const client = new YakClient({ appId: "my-app", onReady: () => {
+     *   client.sendPrompt("Help me with my order");
+     * }});
+     * ```
+     */
+    sendPrompt(prompt) {
+        if (!this.iframeWindow) {
+            logger.warn("Cannot send prompt: iframe not ready");
+            return;
+        }
+        const message = {
+            type: "yak:prompt",
+            payload: { prompt },
+        };
+        this.iframeWindow.postMessage(message, this.getIframeOrigin());
+    }
+    /**
+     * Send a focus request to the chatbot iframe
+     * This will focus the chat input field
+     */
+    sendFocus() {
+        if (!this.iframeWindow) {
+            logger.warn("Cannot send focus: iframe not ready");
+            return;
+        }
+        const message = {
+            type: "yak:focus",
+        };
+        this.iframeWindow.postMessage(message, this.getIframeOrigin());
+    }
+    /**
+     * Check if the iframe is ready to receive messages
+     */
+    isReady() {
+        return this.readyTarget !== null;
+    }
+    setIframeWindow(window) {
+        this.iframeWindow = window;
+        if (!window) {
+            this.readyTarget = null;
+        }
+    }
+    setWidgetOpen(isOpen) {
+        this.isWidgetOpen = isOpen;
+        if (isOpen && this.readyTarget && this.config.chatConfig) {
+            this.sendConfigToIframe(this.readyTarget.window, this.readyTarget.origin);
+        }
+        if (isOpen) {
+            this.startObserving();
+        }
+        else {
+            this.stopObserving();
+        }
+    }
+    mount() {
+        if (typeof window !== "undefined") {
+            window.addEventListener("message", this.handleMessage);
+            window.addEventListener("popstate", this.handlePopState);
+        }
+    }
+    unmount() {
+        if (typeof window !== "undefined") {
+            window.removeEventListener("message", this.handleMessage);
+            window.removeEventListener("popstate", this.handlePopState);
+        }
+        this.stopObserving();
+    }
+    startObserving() {
+        if (typeof window === "undefined" || !this.iframeWindow)
+            return;
+        // Initial check
+        const currentUrl = window.location.href;
+        if (currentUrl !== this.lastUrl) {
+            this.lastUrl = currentUrl;
+            logger.debug("URL changed, sending page context");
+            this.sendPageContext();
+        }
+        if (this.observer)
+            return;
+        this.observer = new MutationObserver((mutations) => {
+            const hasSubstantialChanges = mutations.some((mutation) => mutation.type === "childList" &&
+                (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0));
+            if (hasSubstantialChanges) {
+                this.debouncedSendContext();
+            }
+        });
+        this.observer.observe(document.body, {
+            childList: true,
+            subtree: true,
+        });
+    }
+    stopObserving() {
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+    }
+    handlePopState = () => {
+        logger.debug("Navigation detected, sending page context");
+        this.sendPageContext();
+    };
+    handleMessage = (event) => {
+        if (typeof window === "undefined")
+            return;
+        if (!this.isWidgetOpen && event.data?.type !== "yak:ready") {
+            return;
+        }
+        const hostOrigin = window.location.origin;
+        const allowedOrigins = new Set();
+        allowedOrigins.add(this.getIframeOrigin());
+        if (hostOrigin) {
+            allowedOrigins.add(hostOrigin);
+        }
+        if (!allowedOrigins.has(event.origin)) {
+            if (!this.unexpectedOriginLogged) {
+                logger.warn(`Ignoring message from unexpected origin: ${event.origin}, allowed: ${Array.from(allowedOrigins).join(", ")}`);
+                this.unexpectedOriginLogged = true;
+            }
+            return;
+        }
+        // Validate message structure
+        if (!event.data || typeof event.data !== "object" || !("type" in event.data)) {
+            // Filter out known browser extension messages
+            const data = event.data;
+            const isReactDevTools = data?.source === "react-devtools-content-script" ||
+                data?.source === "react-devtools-bridge" ||
+                data?.source === "react-devtools-inject-backend";
+            const isReduxDevTools = data?.source === "@devtools-page";
+            if (isReactDevTools || isReduxDevTools) {
+                return;
+            }
+            return;
+        }
+        const message = event.data;
+        const targetWindow = (event.source && "postMessage" in event.source ? event.source : null) ??
+            this.iframeWindow;
+        const targetOrigin = this.getIframeOrigin();
+        logger.debug("Message received from iframe:", message.type);
+        switch (message.type) {
+            case "yak:ready": {
+                logger.debug("Iframe ready, sending config");
+                if (targetWindow) {
+                    this.readyTarget = { window: targetWindow, origin: targetOrigin };
+                    this.sendConfigToIframe(targetWindow, targetOrigin);
+                    // Send initial page context after config
+                    setTimeout(() => this.sendPageContext(), 100);
+                    // Mark iframe as ready after config is sent
+                    setTimeout(() => this.config.onReady?.(), 200);
+                }
+                else {
+                    logger.warn("Unable to send config: iframe window not registered yet");
+                }
+                break;
+            }
+            case "yak:tool_call": {
+                const { id, name, args } = message.payload;
+                void this.handleToolCall(id, name, args);
+                break;
+            }
+            case "yak:graphql_schema_call": {
+                const { id, schemaName, request } = message.payload;
+                void this.handleGraphQLSchemaCall(id, schemaName, request);
+                break;
+            }
+            case "yak:rest_schema_call": {
+                const { id, schemaName, request } = message.payload;
+                void this.handleRESTSchemaCall(id, schemaName, request);
+                break;
+            }
+            case "yak:redirect": {
+                const { path } = message.payload;
+                logger.debug("Redirect request received:", path);
+                if (!this.isAllowedRedirect(path)) {
+                    logger.warn("Blocked potentially unsafe redirect:", path);
+                    break;
+                }
+                if (this.config.onRedirect) {
+                    this.config.onRedirect(path);
+                }
+                else if (typeof window !== "undefined") {
+                    window.location.assign(path);
+                }
+                break;
+            }
+            case "yak:close": {
+                logger.debug("Close message received from iframe");
+                this.config.onClose?.();
+                break;
+            }
+            default:
+                logger.debug("Unknown message type:", message.type);
+                break;
+        }
+    };
+    sendConfigToIframe(targetWindow, targetOrigin) {
+        const configMessage = {
+            type: "yak:config",
+            payload: {
+                version: EMBED_PROTOCOL_VERSION,
+                appId: this.config.appId,
+                theme: this.config.theme,
+                toolManifest: this.config.chatConfig?.tools ?? undefined,
+                routeManifest: this.config.chatConfig?.routes ?? undefined,
+                schemaSources: this.config.chatConfig?.schemaSources ?? undefined,
+                options: this.config.options,
+            },
+        };
+        logger.debug("Posting config to iframe origin:", {
+            origin: targetOrigin,
+            version: EMBED_PROTOCOL_VERSION,
+            hasToolManifest: Boolean(this.config.chatConfig?.tools),
+            toolCount: this.config.chatConfig?.tools?.tools.length ?? 0,
+            hasRouteManifest: Boolean(this.config.chatConfig?.routes),
+            hasSchemaSources: Boolean(this.config.chatConfig?.schemaSources),
+            schemaCount: this.config.chatConfig?.schemaSources?.length ?? 0,
+        });
+        targetWindow.postMessage(configMessage, targetOrigin);
+    }
+    sendPageContext() {
+        if (!this.iframeWindow)
+            return;
+        try {
+            const pageContext = extractPageContext();
+            const message = {
+                type: "yak:page_context",
+                payload: pageContext,
+            };
+            logger.debug("Sending page context to iframe:", {
+                url: pageContext.url,
+                title: pageContext.title,
+                textLength: pageContext.text.length,
+            });
+            this.iframeWindow.postMessage(message, this.getIframeOrigin());
+        }
+        catch (error) {
+            logger.error("Error extracting page context:", error);
+        }
+    }
+    async handleToolCall(id, name, args) {
+        logger.debug(`Tool call received: ${name}`, { id, args });
+        if (!this.config.onToolCall) {
+            logger.error("Tool call received but no onToolCall handler configured");
+            this.sendToolResultToIframe(id, false, undefined, "No tool call handler configured");
+            return;
+        }
+        try {
+            const result = await this.config.onToolCall(name, args);
+            logger.debug(`Tool call succeeded: ${name}`, { id });
+            this.sendToolResultToIframe(id, true, result);
+        }
+        catch (error) {
+            logger.error(`Tool call failed: ${name}`, { id, error });
+            this.sendToolResultToIframe(id, false, undefined, this.extractErrorMessage(error));
+        }
+    }
+    async handleGraphQLSchemaCall(id, schemaName, request) {
+        logger.debug(`GraphQL schema call received: ${schemaName}`, { id, request });
+        if (!this.config.onGraphQLSchemaCall) {
+            logger.error("GraphQL schema call received but no onGraphQLSchemaCall handler configured");
+            this.sendToolResultToIframe(id, false, undefined, "No GraphQL schema handler configured");
+            return;
+        }
+        try {
+            const result = await this.config.onGraphQLSchemaCall(schemaName, request);
+            logger.debug(`GraphQL schema call succeeded: ${schemaName}`, { id });
+            this.sendToolResultToIframe(id, true, result);
+        }
+        catch (error) {
+            logger.error(`GraphQL schema call failed: ${schemaName}`, { id, error });
+            this.sendToolResultToIframe(id, false, undefined, this.extractErrorMessage(error));
+        }
+    }
+    async handleRESTSchemaCall(id, schemaName, request) {
+        logger.debug(`REST schema call received: ${schemaName}`, { id, request });
+        if (!this.config.onRESTSchemaCall) {
+            logger.error("REST schema call received but no onRESTSchemaCall handler configured");
+            this.sendToolResultToIframe(id, false, undefined, "No REST schema handler configured");
+            return;
+        }
+        try {
+            const result = await this.config.onRESTSchemaCall(schemaName, request);
+            logger.debug(`REST schema call succeeded: ${schemaName}`, { id });
+            this.sendToolResultToIframe(id, true, result);
+        }
+        catch (error) {
+            logger.error(`REST schema call failed: ${schemaName}`, { id, error });
+            this.sendToolResultToIframe(id, false, undefined, this.extractErrorMessage(error));
+        }
+    }
+    sendToolResultToIframe(id, ok, result, error) {
+        if (!this.iframeWindow)
+            return;
+        if (ok) {
+            // Serialize result to remove non-cloneable values (functions, etc.)
+            // postMessage uses structured clone which cannot handle functions
+            const safeResult = this.toSerializable(result);
+            const message = {
+                type: "yak:tool_result",
+                payload: { id, ok: true, result: safeResult },
+            };
+            this.iframeWindow.postMessage(message, this.getIframeOrigin());
+        }
+        else {
+            const message = {
+                type: "yak:tool_result",
+                payload: { id, ok: false, error: error ?? "Unknown error" },
+            };
+            this.iframeWindow.postMessage(message, this.getIframeOrigin());
+        }
+    }
+    /**
+     * Convert a value to a serializable form by stripping functions and other non-cloneable values.
+     * Uses JSON.parse(JSON.stringify()) which handles most cases.
+     */
+    toSerializable(value) {
+        if (value === undefined || value === null) {
+            return value;
+        }
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch {
+            // If JSON serialization fails, return a string representation
+            logger.warn("Failed to serialize tool result, returning string representation");
+            return String(value);
+        }
+    }
+    extractErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === "string") {
+            return error;
+        }
+        return "Unknown error";
+    }
+    /**
+     * Validates that a redirect path is safe (relative path or same-origin).
+     * Blocks absolute URLs to external domains to prevent open redirect attacks.
+     */
+    isAllowedRedirect(path) {
+        // Allow relative paths that don't start with // (protocol-relative URLs)
+        if (path.startsWith('/') && !path.startsWith('//')) {
+            return true;
+        }
+        // Allow hash-only and query-only paths
+        if (path.startsWith('#') || path.startsWith('?')) {
+            return true;
+        }
+        // For absolute URLs, verify same origin
+        if (typeof window !== "undefined") {
+            try {
+                const url = new URL(path, window.location.origin);
+                return url.origin === window.location.origin;
+            }
+            catch {
+                // Invalid URL - block it
+                return false;
+            }
+        }
+        // In non-browser environments, only allow relative paths
+        return false;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./types/config.js";
+export * from "./types/messaging.js";
+export * from "./types/routes.js";
+export * from "./types/tools.js";
+export { EMBED_PROTOCOL_VERSION } from "./version.js";
+export type { EmbedProtocolVersion } from "./version.js";
+export { YakClient } from "./client.js";
+export type { YakClientConfig } from "./client.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,YAAY,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAGzD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+// Public types
+export * from "./types/config.js";
+export * from "./types/messaging.js";
+export * from "./types/routes.js";
+export * from "./types/tools.js";
+// Version
+export { EMBED_PROTOCOL_VERSION } from "./version.js";
+// Public client API
+export { YakClient } from "./client.js";

package/dist/index.server.d.ts

@@ -0,0 +1,2 @@
+export * from "./server/index.js";
+//# sourceMappingURL=index.server.d.ts.map

package/dist/index.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.server.d.ts","sourceRoot":"","sources":["../src/index.server.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/index.server.js

@@ -0,0 +1 @@
+export * from "./server/index.js";

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Simple logger utility for the yak client SDK.
+ * Debug/info logs are only emitted in development mode.
+ * Warnings and errors are always logged.
+ */
+export declare const logger: {
+    debug: (message: string, data?: unknown) => void;
+    info: (message: string, data?: unknown) => void;
+    warn: (message: string, data?: unknown) => void;
+    error: (message: string, data?: unknown) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,MAAM;qBACA,MAAM,SAAS,OAAO,KAAG,IAAI;oBAU9B,MAAM,SAAS,OAAO,KAAG,IAAI;oBAU7B,MAAM,SAAS,OAAO,KAAG,IAAI;qBAQ5B,MAAM,SAAS,OAAO,KAAG,IAAI;CAO/C,CAAC"}

package/dist/logger.js

@@ -0,0 +1,44 @@
+/**
+ * Simple logger utility for the yak client SDK.
+ * Debug/info logs are only emitted in development mode.
+ * Warnings and errors are always logged.
+ */
+const isDev = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+export const logger = {
+    debug: (message, data) => {
+        if (isDev) {
+            if (data !== undefined) {
+                console.log(`[yak-chat-host] ${message}`, data);
+            }
+            else {
+                console.log(`[yak-chat-host] ${message}`);
+            }
+        }
+    },
+    info: (message, data) => {
+        if (isDev) {
+            if (data !== undefined) {
+                console.info(`[yak-chat-host] ${message}`, data);
+            }
+            else {
+                console.info(`[yak-chat-host] ${message}`);
+            }
+        }
+    },
+    warn: (message, data) => {
+        if (data !== undefined) {
+            console.warn(`[yak-chat-host] ${message}`, data);
+        }
+        else {
+            console.warn(`[yak-chat-host] ${message}`);
+        }
+    },
+    error: (message, data) => {
+        if (data !== undefined) {
+            console.error(`[yak-chat-host] ${message}`, data);
+        }
+        else {
+            console.error(`[yak-chat-host] ${message}`);
+        }
+    },
+};

package/dist/page-context.d.ts

@@ -0,0 +1,10 @@
+import type { PageContext } from "./types/messaging.js";
+/**
+ * Extract page context including URL, title, and visible text content
+ */
+export declare function extractPageContext(): PageContext;
+/**
+ * Debounce function to limit how often a function is called
+ */
+export declare function debounce<T extends (...args: unknown[]) => void>(func: T, wait: number): (...args: Parameters<T>) => void;
+//# sourceMappingURL=page-context.d.ts.map

package/dist/page-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-context.d.ts","sourceRoot":"","sources":["../src/page-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA2CxD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,WAAW,CAehD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,EAC7D,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAclC"}

package/dist/page-context.js

@@ -0,0 +1,69 @@
+/**
+ * Extract visible text content from the DOM, filtering out non-content elements
+ */
+function extractPageText() {
+    if (typeof document === "undefined")
+        return "";
+    // Clone the body to avoid modifying the actual DOM
+    const bodyClone = document.body.cloneNode(true);
+    // Remove script, style, noscript tags and hidden elements
+    const unwantedSelectors = [
+        "script",
+        "style",
+        "noscript",
+        "iframe",
+        "[style*='display: none']",
+        "[style*='display:none']",
+        "[hidden]",
+        ".yak-chat-widget",
+    ];
+    unwantedSelectors.forEach((selector) => {
+        const elements = bodyClone.querySelectorAll(selector);
+        elements.forEach((el) => el.remove());
+    });
+    // Get text content and clean it up
+    let text = bodyClone.textContent || bodyClone.innerText || "";
+    // Normalize whitespace: replace multiple spaces/newlines with single space
+    text = text.replace(/\s+/g, " ").trim();
+    // Limit to reasonable size (100KB max)
+    const maxLength = 100000;
+    if (text.length > maxLength) {
+        text = text.substring(0, maxLength) + "... [truncated]";
+    }
+    return text;
+}
+/**
+ * Extract page context including URL, title, and visible text content
+ */
+export function extractPageContext() {
+    if (typeof window === "undefined") {
+        return {
+            url: "",
+            title: "",
+            text: "",
+            timestamp: Date.now(),
+        };
+    }
+    return {
+        url: window.location.href,
+        title: document.title,
+        text: extractPageText(),
+        timestamp: Date.now(),
+    };
+}
+/**
+ * Debounce function to limit how often a function is called
+ */
+export function debounce(func, wait) {
+    let timeout = null;
+    return function executedFunction(...args) {
+        const later = () => {
+            timeout = null;
+            func(...args);
+        };
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(later, wait);
+    };
+}