@pagelines/sdk 1.0.148

package/dist/sdkClient-BmWhfelO.js

@@ -0,0 +1,939 @@
+var V = Object.defineProperty;
+var Z = (d, o, e) => o in d ? V(d, o, { enumerable: !0, configurable: !0, writable: !0, value: e }) : d[o] = e;
+var l = (d, o) => V(d, "name", { value: o, configurable: !0 });
+var s = (d, o, e) => Z(d, typeof o != "symbol" ? o + "" : o, e);
+import { APP_PORT as F, APP_PROD_URL as D } from "@pagelines/types";
+import { watch as W, ref as C, computed as H } from "vue";
+import { hc as ee } from "hono/client";
+function O(d = {}) {
+  const { prefix: o = "id_" } = d, e = o.length >= 3 ? o.substring(0, 3) : o.padEnd(3, "_"), t = Math.floor(Date.now() / 1e3).toString(16).padStart(8, "0");
+  let r = "";
+  for (let i = 0; i < 16; i++)
+    r += Math.floor(Math.random() * 16).toString(16);
+  return e + t + r;
+}
+l(O, "objectId");
+const b = globalThis.process, m = typeof window < "u", P = typeof b < "u" && !m, I = m ? typeof window < "u" && window.location && !window.location.hostname.includes("localhost") : P && typeof b < "u" && b.env?.NODE_ENV === "production", te = !I, x = {
+  error: { priority: 50, color: "#FF0000", nodeColor: "\x1B[31m" },
+  warn: { priority: 40, color: "#FFA500", nodeColor: "\x1B[33m" },
+  info: { priority: 30, color: "#00ABFF", nodeColor: "\x1B[36m" },
+  debug: { priority: 20, color: "#00BD0C", nodeColor: "\x1B[32m" },
+  trace: { priority: 10, color: "#5233FF", nodeColor: "\x1B[35m" }
+}, oe = ["password", "token", "secret", "apikey", "api_key", "authorization", "cookie"], k = class k {
+  constructor(o = {}, e) {
+    s(this, "settings");
+    s(this, "enabledInBrowser", !1);
+    s(this, "context");
+    this.context = e, this.settings = {
+      enabled: o.enabled ?? !0,
+      minLevel: o.minLevel ?? this.getDefaultLevel(),
+      timestamps: o.timestamps ?? !0
+    }, m && this.initBrowserLogging();
+  }
+  getDefaultLevel() {
+    if (P && typeof b < "u" && b.env?.LOG_LEVEL)
+      return b.env.LOG_LEVEL;
+    if (m && typeof localStorage < "u" && typeof localStorage.getItem == "function") {
+      const o = localStorage.getItem("PAGELINES_LOG_LEVEL");
+      if (o)
+        return o;
+    }
+    return I ? "info" : "debug";
+  }
+  initBrowserLogging() {
+    if (!m)
+      return;
+    const e = typeof localStorage?.getItem == "function" && localStorage.getItem("PAGELINES_LOG") === "true", t = window.location?.hostname || "";
+    this.enabledInBrowser = te || e || t === "localhost" || t.includes("127.0.0.1"), I && !e && !k.hasShownHelp && (console.log(
+      "%cPageLines Logger (disabled in production)",
+      "color: #888; font-size: 12px"
+    ), console.log(
+      '%cTo enable: localStorage.setItem("PAGELINES_LOG", "true")',
+      "color: #888; font-size: 11px"
+    ), k.hasShownHelp = !0);
+  }
+  shouldLog(o) {
+    if (!this.settings.enabled || m && !this.enabledInBrowser)
+      return !1;
+    const e = x[o].priority, t = x[this.settings.minLevel].priority;
+    return e >= t;
+  }
+  formatTimestamp() {
+    return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", {
+      hour12: !1,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+  }
+  formatISOTimestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  redactSensitive(o) {
+    if (typeof o != "object" || o === null)
+      return o;
+    if (Array.isArray(o))
+      return o.map((t) => this.redactSensitive(t));
+    const e = {};
+    for (const [t, r] of Object.entries(o)) {
+      const i = t.toLowerCase();
+      oe.some((n) => i.includes(n)) ? e[t] = "[REDACTED]" : typeof r == "object" && r !== null ? e[t] = this.redactSensitive(r) : e[t] = r;
+    }
+    return e;
+  }
+  formatData(o, e = 3, t = 0) {
+    if (t >= e)
+      return "[Max Depth]";
+    if (o == null)
+      return o;
+    if (o instanceof Error)
+      return {
+        name: o.name,
+        message: o.message,
+        stack: I ? o.stack?.split(`
+`).slice(0, 3).join(`
+`) : o.stack,
+        ...o
+        // Include any additional error properties
+      };
+    if (o instanceof Date)
+      return o.toISOString();
+    if (typeof o != "object")
+      return o;
+    if (Array.isArray(o))
+      return o.length > 20 && I ? `Array(${o.length}) [${o.slice(0, 3).map((r) => this.formatData(r, e, t + 1)).join(", ")}, ...]` : o.map((r) => this.formatData(r, e, t + 1));
+    try {
+      const r = {}, i = Object.entries(o), n = I ? 50 : 200;
+      for (const [c, u] of i.slice(0, n))
+        r[c] = this.formatData(u, e, t + 1);
+      return i.length > n && (r["..."] = `${i.length - n} more properties`), this.redactSensitive(r);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+  logToBrowser(o) {
+    if (!m || !this.shouldLog(o.level))
+      return;
+    const { level: e, description: t, context: r, data: i, error: n } = o, c = x[e], a = `[${r || this.context || "www"}] ${e.toUpperCase()}:`, h = `color: ${c.color}; font-weight: bold;`;
+    i !== void 0 ? console[e](`%c${a}`, h, t, this.formatData(i)) : console[e](`%c${a}`, h, t), n && (n instanceof Error ? console.error(n) : console.error("Error details:", n));
+  }
+  logToNode(o) {
+    if (!P || !this.shouldLog(o.level))
+      return;
+    const { level: e, description: t, context: r, data: i, error: n } = o, c = r || this.context || "www";
+    if (I) {
+      const u = {
+        timestamp: this.formatISOTimestamp(),
+        level: e.toUpperCase()
+      };
+      i && (u.data = this.formatData(i)), n && (u.error = this.formatData(n)), console[e](`${u.timestamp} ${u.level} [${c}] ${t}`, i || n ? JSON.stringify({ data: i, error: n }) : "");
+    } else {
+      const u = x[e], a = this.formatTimestamp(), h = "\x1B[0m", w = "\x1B[2m", S = u.nodeColor || "", g = `${w}${a}${h} ${S}${e.toUpperCase()} (${c}):${h} ${t}`;
+      console[e](g), i !== void 0 && console.log(JSON.stringify(this.formatData(i), null, 2)), n && (n instanceof Error ? (console.error(`\x1B[31mError:${h}`, n.message), n.stack && console.error(`\x1B[90m${n.stack}${h}`)) : console.error("Error:", n));
+    }
+  }
+  log(o) {
+    m ? this.logToBrowser(o) : P && this.logToNode(o);
+  }
+  error(o, e) {
+    this.log({ level: "error", description: o, data: e, context: this.context });
+  }
+  warn(o, e) {
+    this.log({ level: "warn", description: o, data: e, context: this.context });
+  }
+  info(o, e) {
+    this.log({ level: "info", description: o, data: e, context: this.context });
+  }
+  debug(o, e) {
+    this.log({ level: "debug", description: o, data: e, context: this.context });
+  }
+  trace(o, e) {
+    this.log({ level: "trace", description: o, data: e, context: this.context });
+  }
+  isEnabled() {
+    return m ? this.enabledInBrowser : !0;
+  }
+  setLevel(o) {
+    this.settings.minLevel = o;
+  }
+  createContextLogger(o) {
+    const e = new k(this.settings, o);
+    return {
+      error: /* @__PURE__ */ l((t, r) => e.error(t, r), "error"),
+      warn: /* @__PURE__ */ l((t, r) => e.warn(t, r), "warn"),
+      info: /* @__PURE__ */ l((t, r) => e.info(t, r), "info"),
+      debug: /* @__PURE__ */ l((t, r) => e.debug(t, r), "debug"),
+      trace: /* @__PURE__ */ l((t, r) => e.trace(t, r), "trace"),
+      isEnabled: /* @__PURE__ */ l(() => e.isEnabled(), "isEnabled"),
+      setLevel: /* @__PURE__ */ l((t) => e.setLevel(t), "setLevel")
+    };
+  }
+};
+l(k, "Logger"), s(k, "hasShownHelp", !1);
+let j = k;
+function Y(d) {
+  return new j({}, d).createContextLogger(d);
+}
+l(Y, "createLogger");
+const v = new j();
+v.error.bind(v);
+v.warn.bind(v);
+v.info.bind(v);
+v.debug.bind(v);
+v.trace.bind(v);
+const K = class K {
+  constructor(o, e) {
+    s(this, "name");
+    s(this, "settings");
+    s(this, "logger");
+    this.name = o, this.settings = e, this.logger = Y(o);
+  }
+};
+l(K, "SettingsObject");
+let G = K;
+const q = class q {
+  constructor() {
+    // Configuration properties
+    s(this, "tokenName", "auth-token");
+    s(this, "tokenMaxAge", 3600 * 24 * 7);
+    // 7 days
+    s(this, "fallbackStorageKey", "token");
+    // For localStorage migration
+    s(this, "productionDomain", ".pagelines.com");
+  }
+  /**
+   * Get cookie value by name
+   */
+  getCookie(o) {
+    if (typeof document > "u")
+      return null;
+    const e = document.cookie.split(";");
+    for (const t of e) {
+      const [r, i] = t.trim().split("=");
+      if (r === o)
+        return decodeURIComponent(i || "");
+    }
+    return null;
+  }
+  /**
+   * Set cookie with secure defaults
+   */
+  setCookie(o, e, t = {}) {
+    if (typeof document > "u")
+      return;
+    const {
+      secure: r = !0,
+      sameSite: i = "lax",
+      maxAge: n = 3600 * 24 * 7,
+      // 7 days default
+      domain: c,
+      path: u = "/"
+    } = t;
+    let a = `${o}=${encodeURIComponent(e)}`;
+    a += `; Path=${u}`, a += `; Max-Age=${n}`, a += `; SameSite=${i}`, r && (a += "; Secure"), c && (a += `; Domain=${c}`), document.cookie = a;
+  }
+  /**
+   * Remove cookie by setting expired date
+   */
+  removeCookie(o, e = {}) {
+    this.setCookie(o, "", { ...e, maxAge: 0 });
+  }
+  /**
+   * Check if localStorage is fully functional (some test environments provide partial mocks)
+   */
+  isLocalStorageFunctional() {
+    return typeof window < "u" && typeof window.localStorage?.getItem == "function" && typeof window.localStorage?.setItem == "function" && typeof window.localStorage?.removeItem == "function";
+  }
+  /**
+   * Get auth token with fallback to localStorage for migration
+   */
+  getAuthToken() {
+    const o = this.getCookie(this.tokenName);
+    if (o)
+      return o;
+    if (this.isLocalStorageFunctional()) {
+      const e = window.localStorage.getItem(this.fallbackStorageKey);
+      if (e)
+        return this.setAuthToken(e), window.localStorage.removeItem(this.fallbackStorageKey), e;
+    }
+    return null;
+  }
+  /**
+   * Set auth token in cookie with production-ready settings
+   */
+  setAuthToken(o) {
+    const e = typeof window < "u" && window.location.hostname !== "localhost";
+    this.setCookie(this.tokenName, o, {
+      secure: e,
+      sameSite: "lax",
+      maxAge: this.tokenMaxAge,
+      domain: e ? this.productionDomain : void 0,
+      path: "/"
+    });
+  }
+  /**
+   * Remove auth token
+   */
+  removeAuthToken() {
+    const o = typeof window < "u" && window.location.hostname !== "localhost";
+    this.removeCookie(this.tokenName, {
+      domain: o ? this.productionDomain : void 0,
+      path: "/"
+    }), this.isLocalStorageFunctional() && window.localStorage.removeItem(this.fallbackStorageKey);
+  }
+};
+l(q, "CookieUtil");
+let M = q;
+const $ = new M();
+function re(d, o) {
+  const e = d.apiBase || (d.isDev ? `http://localhost:${F}` : D);
+  return ee(e, {
+    fetch: /* @__PURE__ */ l(async (r, i) => {
+      const n = $.getAuthToken(), c = await fetch(r, {
+        ...i,
+        headers: {
+          ...i?.headers,
+          "Content-Type": "application/json",
+          // Only include Authorization header if token exists
+          ...n && { Authorization: `Bearer ${n}` }
+        },
+        // Use 'omit' for Bearer tokens (not cookies) to allow CORS wildcard origin
+        credentials: "omit"
+      });
+      if (o) {
+        const u = c.json.bind(c);
+        c.json = async () => {
+          const a = await u();
+          return typeof a == "object" && a !== null && "ok" in a && ("user" in a || "token" in a) && o(a), a;
+        };
+      }
+      return c;
+    }, "fetch")
+  });
+}
+l(re, "createApiClient");
+let ie = /* @__PURE__ */ Symbol("clean"), f = [], y = 0;
+const A = 4, X = /* @__PURE__ */ l(/* @__NO_SIDE_EFFECTS__ */ (d) => {
+  let o = [], e = {
+    get() {
+      return e.lc || e.listen(() => {
+      })(), e.value;
+    },
+    lc: 0,
+    listen(t) {
+      return e.lc = o.push(t), () => {
+        for (let i = y + A; i < f.length; )
+          f[i] === t ? f.splice(i, A) : i += A;
+        let r = o.indexOf(t);
+        ~r && (o.splice(r, 1), --e.lc || e.off());
+      };
+    },
+    notify(t, r) {
+      let i = !f.length;
+      for (let n of o)
+        f.push(n, e.value, t, r);
+      if (i) {
+        for (y = 0; y < f.length; y += A)
+          f[y](
+            f[y + 1],
+            f[y + 2],
+            f[y + 3]
+          );
+        f.length = 0;
+      }
+    },
+    /* It will be called on last listener unsubscribing.
+       We will redefine it in onMount and onStop. */
+    off() {
+    },
+    set(t) {
+      let r = e.value;
+      r !== t && (e.value = t, e.notify(r));
+    },
+    subscribe(t) {
+      let r = e.listen(t);
+      return t(e.value), r;
+    },
+    value: d
+  };
+  return process.env.NODE_ENV !== "production" && (e[ie] = () => {
+    o = [], e.lc = 0, e.off();
+  }), e;
+}, "atom"), U = /* @__PURE__ */ X(void 0), T = /* @__PURE__ */ X(null), z = class z {
+  constructor() {
+    s(this, "logger", Y("SDKStorage"));
+  }
+  /**
+   * Check if localStorage is fully functional (some test environments provide partial mocks)
+   */
+  isLocalStorageFunctional() {
+    return typeof window < "u" && typeof localStorage?.getItem == "function" && typeof localStorage?.setItem == "function" && typeof localStorage?.removeItem == "function";
+  }
+  /**
+   * Sync Vue reactive refs with global nanostores for cross-page persistence
+   */
+  syncWithGlobalStores(o, e) {
+    const t = U.get(), r = T.get();
+    t && (o.value = t), r && (e.value = r), W(o, (i) => {
+      U.set(i);
+    }, { immediate: !0 }), W(e, (i) => {
+      T.set(i);
+    }, { immediate: !0 }), U.subscribe((i) => {
+      i !== o.value && (o.value = i);
+    }), T.subscribe((i) => {
+      i !== e.value && (e.value = i);
+    });
+  }
+  /**
+   * Load user and token from browser storage on initialization
+   */
+  loadFromStorage(o, e) {
+    if (typeof window > "u")
+      return;
+    const t = $.getAuthToken();
+    if (t && (e.value = t), this.isLocalStorageFunctional())
+      try {
+        const r = localStorage.getItem("pagelines-user");
+        r && (o.value = JSON.parse(r));
+      } catch (r) {
+        this.logger.error("Failed to load user from localStorage", { data: r });
+      }
+  }
+  /**
+   * Save current user and token to browser storage
+   */
+  saveToStorage(o, e) {
+    if (!(typeof window > "u") && (e.value ? $.setAuthToken(e.value) : $.removeAuthToken(), this.isLocalStorageFunctional()))
+      try {
+        o.value ? localStorage.setItem("pagelines-user", JSON.stringify(o.value)) : localStorage.removeItem("pagelines-user");
+      } catch (t) {
+        this.logger.error("Failed to save user to localStorage", { data: t });
+      }
+  }
+  /**
+   * Clear all stored user data and tokens
+   */
+  clearStorage() {
+    if (!(typeof window > "u")) {
+      if ($.removeAuthToken(), this.isLocalStorageFunctional())
+        try {
+          localStorage.removeItem("pagelines-user");
+        } catch (o) {
+          this.logger.error("Failed to clear user from localStorage", { data: o });
+        }
+      U.set(void 0), T.set(null);
+    }
+  }
+  /**
+   * Generic localStorage getter
+   */
+  getItem(o) {
+    if (!this.isLocalStorageFunctional())
+      return null;
+    try {
+      return localStorage.getItem(o);
+    } catch (e) {
+      return this.logger.error("Failed to get item from localStorage", { key: o, error: e }), null;
+    }
+  }
+  /**
+   * Generic localStorage setter
+   */
+  setItem(o, e) {
+    if (this.isLocalStorageFunctional())
+      try {
+        localStorage.setItem(o, e);
+      } catch (t) {
+        this.logger.error("Failed to set item in localStorage", { key: o, error: t });
+      }
+  }
+};
+l(z, "SDKStorage");
+let R = z;
+const J = class J {
+  constructor() {
+    s(this, "key", "__PAGELINES_SDK__");
+  }
+  get() {
+    if (!(typeof window > "u"))
+      return globalThis[this.key];
+  }
+  set(o) {
+    typeof window < "u" && (globalThis[this.key] = o);
+  }
+  delete() {
+    typeof window < "u" && delete globalThis[this.key];
+  }
+};
+l(J, "SDKGlobal");
+let _ = J;
+const B = new _(), N = class N extends G {
+  constructor(e = {}) {
+    const t = B.get();
+    if (t)
+      return console.debug("[PageLinesSDK] Returning existing singleton instance"), t;
+    super("PageLinesSDK", e);
+    // Vue reactive state
+    s(this, "activeUser", C());
+    s(this, "token", C(null));
+    s(this, "loading", C(!1));
+    s(this, "error", C(null));
+    s(this, "apiBase", this.settings.apiBase || void 0);
+    // Storage handler for persistence
+    s(this, "storage", new R());
+    // Auto-managed session ID for usage tracking
+    s(this, "sessionId", O({ prefix: "ses" }));
+    // Typed Hono RPC client - uses SDKAppType (auth/self/usage routes only)
+    // Initialized in constructor (definite assignment via singleton pattern)
+    s(this, "apiClient");
+    // Computed properties derived from activeUser (matches UserClient pattern)
+    s(this, "currentAgent", H(() => {
+      const e = this.activeUser.value;
+      if (!e?.agents)
+        return;
+      const t = e.primaryAgentId || e.agents[0]?.agentId;
+      if (t)
+        return e.agents.find((r) => r.agentId === t);
+    }));
+    s(this, "currentOrg", H(() => {
+      const e = this.currentAgent.value;
+      if (!e?.orgId)
+        return;
+      const t = this.activeUser.value;
+      if (t?.orgs)
+        return t.orgs.find((r) => r.orgId === e.orgId);
+    }));
+    // Initialization state
+    s(this, "initialized");
+    s(this, "resolveUser");
+    B.set(this), this.apiClient = re(
+      { isDev: this.isDev, apiBase: this.apiBase },
+      this.processApiResponse.bind(this)
+    ), this.logger.info("PageLinesSDK initialized"), this.storage.loadFromStorage(this.activeUser, this.token), this.storage.syncWithGlobalStores(this.activeUser, this.token), this.initialized = new Promise((r) => {
+      this.resolveUser = r;
+    }), this.token.value && !this.activeUser.value ? this.getCurrentUser().then((r) => {
+      this.resolveUser && (this.resolveUser(r), this.resolveUser = void 0);
+    }).catch((r) => {
+      this.logger.error("Auto user fetch failed", { data: r }), this.resolveUser && (this.resolveUser(void 0), this.resolveUser = void 0);
+    }) : this.activeUser.value ? this.resolveUser?.(this.activeUser.value) : this.resolveUser?.(void 0);
+  }
+  /**
+   * Get singleton instance in browser (creates if doesn't exist)
+   * Node.js: Always creates new instance (no singleton)
+   * Recommended: Use this instead of constructor for shared state
+   */
+  static getInstance(e = {}) {
+    return B.get() || new N(e);
+  }
+  get isDev() {
+    return this.settings.isDev ?? (typeof window < "u" ? window.location.hostname === "localhost" || window.location.hostname.includes("127.0.0.1") : !1);
+  }
+  // Bypass stub typing for route access (production builds use SDKAppType stub)
+  // Runtime types are validated via Zod at API boundaries
+  get api() {
+    return this.apiClient.api;
+  }
+  // Process ApiResponse for automatic user/token updates - public for dependency injection
+  processApiResponse(e) {
+    e.ok && e.user && (this.activeUser.value = e.user, this.logger.info("User updated from API response", { data: e.user })), e.ok && e.token && (this.token.value = e.token, this.storage.saveToStorage(this.activeUser, this.token), this.logger.info("Token updated from API response")), this.resolveUser && e.ok && (this.resolveUser(e.user), this.resolveUser = void 0);
+  }
+  // Clear all user data and tokens
+  clearSession() {
+    this.logger.info("Clearing session"), this.activeUser.value = void 0, this.token.value = null, this.error.value = null, this.storage.clearStorage();
+  }
+  // Full reset - clears session + state + destroys singleton
+  clear() {
+    this.logger.info("Clearing SDK completely"), this.clearSession(), this.loading.value = !1, this.sessionId = O({ prefix: "ses" }), B.delete();
+  }
+  // Convenience methods for common auth operations
+  async sendCode(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const r = await (await this.api.auth["check-email"].$post({
+        json: { email: e }
+      })).json();
+      if (!r.ok)
+        throw this.error.value = r.error, new Error(r.error);
+    } catch (t) {
+      this.logger.error("Send code error", { data: t });
+      const r = t instanceof Error ? t.message : "Failed to send verification code";
+      throw this.error.value = r, t;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async verifyCode(e, t) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const i = await (await this.api.auth["verify-code"].$post({
+        json: { email: e, code: t }
+      })).json();
+      if (!i.ok)
+        throw this.error.value = i.error, new Error(i.error);
+    } catch (r) {
+      this.logger.error("Verify code error", { data: r });
+      const i = r instanceof Error ? r.message : "Failed to verify code";
+      throw this.error.value = i, r;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async login(e, t) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const i = await (await this.api.auth.login.$post({
+        json: { email: e, password: t }
+      })).json();
+      if (!i.ok)
+        throw this.error.value = i.error, new Error(i.error);
+    } catch (r) {
+      this.logger.error("Login error", { data: r });
+      const i = r instanceof Error ? r.message : "Login failed";
+      throw this.error.value = i, r;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async logout() {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      await this.api.auth.logout.$post(), this.activeUser.value = void 0, this.token.value = null, this.storage.clearStorage();
+    } catch (e) {
+      this.logger.error("Logout error (user still logged out locally)", { data: e }), this.activeUser.value = void 0, this.token.value = null, this.storage.clearStorage();
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async getCurrentUser() {
+    if (this.token.value) {
+      this.loading.value = !0;
+      try {
+        const t = await (await this.api.auth.me.$get()).json();
+        if (!t.ok) {
+          this.error.value = t.error, t.error.includes("Authentication") && (this.activeUser.value = void 0, this.token.value = null, this.storage.clearStorage());
+          return;
+        }
+        return t.user;
+      } catch (e) {
+        this.logger.error("Get current user error", { data: e }), this.error.value = e instanceof Error ? e.message : "Failed to get user info";
+        return;
+      } finally {
+        this.loading.value = !1;
+      }
+    }
+  }
+  async getPublicAgent(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const r = await (await this.api.agent.public[":handle"].$get({
+        param: { handle: e.handle }
+      })).json();
+      if (!r.ok) {
+        this.error.value = r.error, this.logger.error("Failed to fetch public agent", { handle: e.handle, error: r.error });
+        return;
+      }
+      return r.data;
+    } catch (t) {
+      this.logger.error("Get public agent error", { handle: e.handle, error: t }), this.error.value = t instanceof Error ? t.message : "Failed to fetch agent";
+      return;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async getAgentByEmail(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const r = await (await this.api.agent["by-email"][":email"].$get({
+        param: { email: e.email }
+      })).json();
+      if (!r.ok) {
+        this.error.value = r.error, this.logger.error("Failed to fetch agent by email", { email: e.email, error: r.error });
+        return;
+      }
+      return r.data;
+    } catch (t) {
+      this.logger.error("Get agent by email error", { email: e.email, error: t }), this.error.value = t instanceof Error ? t.message : "Failed to fetch agent";
+      return;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async requestAuthCode(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const r = await (await this.api.auth["check-email"].$post({
+        json: { email: e.email }
+      })).json();
+      return r.ok ? (this.logger.info("Auth code requested successfully", { email: e.email }), !0) : (this.error.value = r.error, this.logger.error("Failed to request auth code", { email: e.email, error: r.error }), !1);
+    } catch (t) {
+      return this.logger.error("Request auth code error", { email: e.email, error: t }), this.error.value = t instanceof Error ? t.message : "Failed to request auth code", !1;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async loginWithCode(e) {
+    this.loading.value = !0, this.error.value = null;
+    try {
+      const r = await (await this.api.auth["verify-code"].$post({
+        json: { email: e.email, code: e.code }
+      })).json();
+      return this.logger.info("Login with code response", {
+        hasUser: !!r.user,
+        hasToken: !!r.token,
+        ok: r.ok
+      }), r.ok ? (this.logger.info("Login successful", { email: e.email }), e.orgId && e.autoCreateContact !== !1 && this.activeUser.value?.userId && await this.autoCreateContact({
+        userId: this.activeUser.value.userId,
+        orgId: e.orgId
+      }), !0) : (this.error.value = r.error, this.logger.error("Login failed", { email: e.email, error: r.error }), !1);
+    } catch (t) {
+      return this.logger.error("Login with code error", { email: e.email, error: t }), this.error.value = t instanceof Error ? t.message : "Login failed", !1;
+    } finally {
+      this.loading.value = !1;
+    }
+  }
+  async trackUsage(e) {
+    try {
+      const t = this.currentAgent.value;
+      if (!t?.orgId)
+        return this.logger.error("Cannot track usage: no current agent with orgId", { args: e }), !1;
+      const i = await (await this.api.usage.record.$post({
+        json: {
+          orgId: t.orgId,
+          agentId: e.agentId,
+          sessionId: this.sessionId,
+          // Auto-managed by SDK
+          type: e.type,
+          quantity: e.quantity,
+          // Track the participant if provided, otherwise use current user or anonymous
+          userId: e.participantId || this.activeUser.value?.userId || "anonymous"
+        }
+      })).json();
+      return i.ok ? !0 : (this.logger.error("Failed to track usage", { error: i.error, args: e }), !1);
+    } catch (t) {
+      return this.logger.error("Track usage error", { error: t, args: e }), !1;
+    }
+  }
+  /**
+   * Auto-create contact on authentication
+   * Called internally by loginWithCode - can be disabled with autoCreateContact: false
+   */
+  async autoCreateContact(e) {
+    try {
+      const r = await (await this.api.contact.resolve.$post({
+        json: { userId: e.userId, orgId: e.orgId }
+      })).json();
+      return r.ok ? (this.logger.info("Contact resolved", { userId: e.userId, orgId: e.orgId }), !0) : (this.logger.error("Failed to auto-create contact", { error: r.error, args: e }), !1);
+    } catch (t) {
+      return this.logger.error("Auto-create contact error", { error: t, args: e }), !1;
+    }
+  }
+  /**
+   * Start conversation session (auto-creates conversation if needed)
+   * Returns conversation data for tracking messages
+   */
+  async startConversation(e) {
+    try {
+      const t = this.currentAgent.value;
+      if (!t?.orgId) {
+        this.logger.error("Cannot start conversation: no current agent with orgId", { args: e });
+        return;
+      }
+      const i = await (await this.api.conversation.start.$post({
+        json: {
+          orgId: t.orgId,
+          agentId: e.agentId,
+          userId: e.userId || this.activeUser.value?.userId,
+          anonId: e.anonId,
+          channel: e.channel
+        }
+      })).json();
+      if (!i.ok || !i.data) {
+        const n = i.ok ? "No conversation data returned" : "error" in i ? i.error : "Unknown error";
+        this.logger.error("Failed to start conversation", { error: n, args: e });
+        return;
+      }
+      return this.logger.info("Conversation started", { conversationId: i.data.conversationId }), i.data;
+    } catch (t) {
+      this.logger.error("Start conversation error", { error: t, args: e });
+      return;
+    }
+  }
+  /**
+   * Generate anonymous ID for tracking unauthenticated users
+   * Stored in localStorage for persistence across sessions
+   */
+  generateAnonId() {
+    const e = "pagelinesAnonId";
+    let t = this.storage.getItem(e);
+    return t || (t = O({ prefix: "anon" }), this.storage.setItem(e, t)), t;
+  }
+  /**
+   * Save message to conversation
+   * Called by AgentController to persist messages
+   */
+  async saveMessage(e) {
+    try {
+      const r = await (await this.api.conversation.messages.$post({
+        json: {
+          sessionId: e.conversationId,
+          participantId: e.participantId,
+          content: e.content,
+          role: e.role
+        }
+      })).json();
+      return r.ok ? !0 : (this.logger.error("Failed to save message", { error: "error" in r ? r.error : "Unknown error", args: e }), !1);
+    } catch (t) {
+      return this.logger.error("Save message error", { error: t, args: e }), !1;
+    }
+  }
+  /**
+   * Stream chat with a public agent (no auth required).
+   * Uses raw fetch + SSE parsing for streaming responses.
+   */
+  async chatStream(e) {
+    const r = `${this.apiBase || (this.isDev ? `http://localhost:${F}` : D)}/api/agent/public/${encodeURIComponent(e.handle)}/chat/stream`;
+    try {
+      const i = await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: e.message,
+          conversationId: e.conversationId,
+          history: e.history,
+          visitorId: e.visitorId
+        })
+      });
+      if (!i.ok) {
+        const h = await i.json().catch(() => ({ error: "Request failed" }));
+        e.onError(h.error || `HTTP ${i.status}`);
+        return;
+      }
+      const n = i.body?.getReader();
+      if (!n) {
+        e.onError("No response stream");
+        return;
+      }
+      const c = new TextDecoder();
+      let u = "", a = e.conversationId || "";
+      for (; ; ) {
+        const { done: h, value: w } = await n.read();
+        if (h)
+          break;
+        u += c.decode(w, { stream: !0 });
+        const S = u.split(`
+`);
+        u = S.pop() || "";
+        for (const g of S) {
+          if (!g.startsWith("data: "))
+            continue;
+          const L = g.slice(6).trim();
+          if (L === "[DONE]") {
+            e.onDone(a);
+            return;
+          }
+          try {
+            const p = JSON.parse(L);
+            p.pl_metadata?.conversationId && (a = p.pl_metadata.conversationId);
+            const E = p.choices?.[0]?.delta;
+            E?.content && e.onDelta(E.content);
+          } catch {
+          }
+        }
+      }
+      e.onDone(a);
+    } catch (i) {
+      e.onError(i instanceof Error ? i.message : "Stream failed");
+    }
+  }
+  /**
+   * Non-streaming chat with a public agent (no auth required).
+   */
+  async chatMessage(e) {
+    const r = `${this.apiBase || (this.isDev ? `http://localhost:${F}` : D)}/api/agent/public/${encodeURIComponent(e.handle)}/chat`;
+    try {
+      const n = await (await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: e.message,
+          conversationId: e.conversationId,
+          visitorId: e.visitorId
+        })
+      })).json();
+      if (!n.ok || !n.data) {
+        this.logger.error("chatMessage failed", { error: !n.ok && "error" in n ? n.error : "Unknown" });
+        return;
+      }
+      return {
+        conversationId: n.data.conversationId,
+        content: n.data.message.content
+      };
+    } catch (i) {
+      this.logger.error("chatMessage error", { error: i });
+      return;
+    }
+  }
+  /**
+   * Sign in with Google via popup window
+   * Opens app.pagelines.com/auth/google-popup which handles the full OAuth flow,
+   * then postMessages the token/user back to this window.
+   */
+  loginWithGoogle(e) {
+    if (typeof window > "u") {
+      this.logger.error("loginWithGoogle: Only available in browser");
+      return;
+    }
+    const t = this.apiBase || (this.isDev ? `http://localhost:${F}` : D), r = window.location.origin, i = `${t}/auth/google-popup?origin=${encodeURIComponent(r)}`, n = 500, c = 600, u = window.screenX + (window.outerWidth - n) / 2, a = window.screenY + (window.outerHeight - c) / 2, h = window.open(
+      i,
+      "google-auth",
+      `width=${n},height=${c},left=${u},top=${a},popup=yes`
+    );
+    if (!h) {
+      const g = "Popup was blocked. Please allow popups for this site.";
+      this.error.value = g, e?.onError?.(g);
+      return;
+    }
+    const w = /* @__PURE__ */ l((g) => {
+      const L = new URL(t).origin;
+      if (g.origin === L) {
+        if (g.data?.type === "auth-success") {
+          window.removeEventListener("message", w);
+          const { token: p, user: E } = g.data;
+          this.processApiResponse({ ok: !0, data: {}, token: p, user: E }), this.logger.info("Google login successful"), e?.onSuccess?.(E);
+        } else if (g.data?.type === "auth-error") {
+          window.removeEventListener("message", w);
+          const p = g.data.error || "Google authentication failed";
+          this.error.value = p, this.logger.error("Google login failed", { error: p }), e?.onError?.(p);
+        }
+      }
+    }, "handler");
+    window.addEventListener("message", w);
+    const S = setInterval(() => {
+      h.closed && (clearInterval(S), window.removeEventListener("message", w));
+    }, 500);
+  }
+  /**
+   * Track conversion events (view_profile, profile_interaction)
+   * Sends event to parent window if embedded, otherwise logs locally
+   */
+  track(e) {
+    try {
+      typeof window < "u" && window.parent !== window && window.parent.postMessage({
+        type: "pagelines_track",
+        event: e.event,
+        agentId: e.agentId,
+        properties: e.properties || {}
+      }, "*"), this.logger.info("SDK event tracked", { event: e.event, agentId: e.agentId });
+    } catch (t) {
+      this.logger.error("Track event error", { error: t, args: e });
+    }
+  }
+};
+l(N, "PageLinesSDK");
+let Q = N;
+export {
+  Q as P,
+  G as S,
+  Y as c
+};
+//# sourceMappingURL=sdkClient-BmWhfelO.js.map