@agent-analytics/paperclip-live-analytics-plugin 0.1.0 → 0.1.1

package/dist/worker.js

@@ -0,0 +1,1165 @@
+// src/paperclip/worker-entry.js
+import { definePlugin, runWorker } from "@paperclipai/plugin-sdk";
+
+// src/shared/constants.js
+var PLUGIN_ID = "@agent-analytics/paperclip-live-analytics-plugin";
+var PLUGIN_DISPLAY_NAME = "Agent Analytics Live";
+var DEFAULT_BASE_URL = "https://api.agentanalytics.sh";
+var DEFAULT_LIVE_WINDOW_SECONDS = 60;
+var DEFAULT_POLL_INTERVAL_SECONDS = 15;
+var MIN_LIVE_WINDOW_SECONDS = 10;
+var MAX_LIVE_WINDOW_SECONDS = 300;
+var MIN_POLL_INTERVAL_SECONDS = 5;
+var MAX_POLL_INTERVAL_SECONDS = 60;
+var DEFAULT_SNOOZE_MINUTES = 30;
+var MAX_ENABLED_ASSET_STREAMS = 10;
+var LIVE_STREAM_CHANNEL = "agent-analytics-live";
+var STATE_NAMESPACE = "agent-analytics-live";
+var DATA_KEYS = {
+  livePageLoad: "live.page.load",
+  liveWidgetLoad: "live.widget.load",
+  settingsLoad: "settings.load"
+};
+var ACTION_KEYS = {
+  authStart: "auth.start",
+  authComplete: "auth.complete",
+  authDisconnect: "auth.disconnect",
+  authReconnect: "auth.reconnect",
+  settingsSave: "settings.save",
+  mappingUpsert: "mapping.upsert",
+  mappingRemove: "mapping.remove",
+  assetSnooze: "asset.snooze",
+  assetUnsnooze: "asset.unsnooze"
+};
+var AGENT_SESSION_SCOPES = [
+  "account:read",
+  "projects:write",
+  "analytics:read",
+  "live:read"
+];
+var ASSET_KINDS = ["website", "docs", "app", "api", "other"];
+
+// src/shared/defaults.js
+function createDefaultSettings() {
+  return {
+    agentAnalyticsBaseUrl: DEFAULT_BASE_URL,
+    liveWindowSeconds: DEFAULT_LIVE_WINDOW_SECONDS,
+    pollIntervalSeconds: DEFAULT_POLL_INTERVAL_SECONDS,
+    monitoredAssets: [],
+    pluginEnabled: true
+  };
+}
+function createDefaultAuthState() {
+  return {
+    mode: "agent_session",
+    accessToken: null,
+    refreshToken: null,
+    accessExpiresAt: null,
+    refreshExpiresAt: null,
+    accountSummary: null,
+    tier: null,
+    status: "disconnected",
+    pendingAuthRequest: null,
+    lastValidatedAt: null,
+    lastError: null
+  };
+}
+function createDefaultSnoozeState() {
+  return {};
+}
+function createEmptyCompanyLiveState() {
+  return {
+    type: "live_state",
+    generatedAt: Date.now(),
+    pluginEnabled: true,
+    authStatus: "disconnected",
+    tier: null,
+    account: null,
+    connection: {
+      status: "idle",
+      label: "Not connected",
+      detail: "Connect Agent Analytics from settings to start the live feed."
+    },
+    metrics: {
+      activeVisitors: 0,
+      activeSessions: 0,
+      eventsPerMinute: 0,
+      assetsConfigured: 0,
+      assetsVisible: 0,
+      countriesTracked: 0
+    },
+    world: {
+      hotCountry: null,
+      countries: []
+    },
+    evidence: {
+      topPages: [],
+      topEvents: [],
+      recentEvents: [],
+      countries: []
+    },
+    assets: [],
+    snoozedAssets: [],
+    warnings: []
+  };
+}
+
+// src/shared/live-state.js
+function clampNumber(value, min, max, fallback) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(max, Math.max(min, Math.round(parsed)));
+}
+function sortCountRows(rows, countKey) {
+  return [...rows].sort((left, right) => {
+    if ((right[countKey] || 0) !== (left[countKey] || 0)) {
+      return (right[countKey] || 0) - (left[countKey] || 0);
+    }
+    return String(left.label || left.path || left.event || "").localeCompare(
+      String(right.label || right.path || right.event || "")
+    );
+  });
+}
+function sortCountries(rows) {
+  return [...rows].sort((left, right) => {
+    if ((right.visitors || 0) !== (left.visitors || 0)) return (right.visitors || 0) - (left.visitors || 0);
+    if ((right.sessions || 0) !== (left.sessions || 0)) return (right.sessions || 0) - (left.sessions || 0);
+    if ((right.events || 0) !== (left.events || 0)) return (right.events || 0) - (left.events || 0);
+    return String(left.country || "").localeCompare(String(right.country || ""));
+  });
+}
+function clampLiveWindowSeconds(value) {
+  return clampNumber(value, MIN_LIVE_WINDOW_SECONDS, MAX_LIVE_WINDOW_SECONDS, DEFAULT_LIVE_WINDOW_SECONDS);
+}
+function clampPollIntervalSeconds(value) {
+  return clampNumber(value, MIN_POLL_INTERVAL_SECONDS, MAX_POLL_INTERVAL_SECONDS, DEFAULT_POLL_INTERVAL_SECONDS);
+}
+function slugifyAssetKey(value) {
+  return String(value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+function normalizeAssetMapping(input = {}) {
+  const label = String(input.label || "").trim();
+  const assetKey = slugifyAssetKey(input.assetKey || label || "asset");
+  const kind = ASSET_KINDS.includes(input.kind) ? input.kind : "other";
+  const project = String(input.agentAnalyticsProject || "").trim();
+  return {
+    assetKey,
+    label: label || assetKey,
+    kind,
+    paperclipProjectId: input.paperclipProjectId ? String(input.paperclipProjectId).trim() : "",
+    agentAnalyticsProject: project,
+    primaryHostname: input.primaryHostname ? String(input.primaryHostname).trim() : "",
+    allowedOrigins: Array.isArray(input.allowedOrigins) ? input.allowedOrigins.map((value) => String(value).trim()).filter(Boolean) : [],
+    enabled: input.enabled !== false
+  };
+}
+function buildStreamFilter(mapping) {
+  const clauses = [];
+  if (mapping.primaryHostname) clauses.push(`hostname:${mapping.primaryHostname}`);
+  return clauses.join(";") || null;
+}
+function mappingSignature(mapping) {
+  return JSON.stringify({
+    project: mapping.agentAnalyticsProject,
+    filter: buildStreamFilter(mapping)
+  });
+}
+function createEmptyAssetState(mapping, now = Date.now()) {
+  return {
+    assetKey: mapping.assetKey,
+    label: mapping.label,
+    kind: mapping.kind,
+    paperclipProjectId: mapping.paperclipProjectId || "",
+    agentAnalyticsProject: mapping.agentAnalyticsProject,
+    primaryHostname: mapping.primaryHostname || "",
+    allowedOrigins: mapping.allowedOrigins || [],
+    enabled: mapping.enabled !== false,
+    status: "idle",
+    lastUpdatedAt: now,
+    lastSnapshotAt: null,
+    lastPolledAt: null,
+    lastHotCountry: null,
+    activeVisitors: 0,
+    activeSessions: 0,
+    eventsPerMinute: 0,
+    topPages: [],
+    topEvents: [],
+    countries: [],
+    recentEvents: [],
+    warnings: [],
+    errors: []
+  };
+}
+function normalizeLiveSnapshot(snapshot = {}) {
+  return {
+    project: snapshot.project || "",
+    windowSeconds: clampLiveWindowSeconds(snapshot.window_seconds),
+    timestamp: snapshot.timestamp || Date.now(),
+    activeVisitors: Number(snapshot.active_visitors || 0),
+    activeSessions: Number(snapshot.active_sessions || 0),
+    eventsPerMinute: Number(snapshot.events_per_minute || 0),
+    topPages: (snapshot.top_pages || []).map((row) => ({
+      path: String(row.path || ""),
+      visitors: Number(row.visitors || 0)
+    })),
+    topEvents: (snapshot.top_events || []).map((row) => ({
+      event: String(row.event || ""),
+      count: Number(row.count || 0)
+    })),
+    countries: sortCountries(
+      (snapshot.countries || []).map((row) => ({
+        country: String(row.country || ""),
+        visitors: Number(row.visitors || 0),
+        sessions: Number(row.sessions || 0),
+        events: Number(row.events || 0)
+      }))
+    ),
+    recentEvents: (snapshot.recent_events || []).map((row, index) => ({
+      id: `${row.session_id || row.user_id || row.timestamp || "event"}-${index}`,
+      event: String(row.event || ""),
+      properties: row.properties || {},
+      userId: row.user_id || null,
+      sessionId: row.session_id || null,
+      timestamp: Number(row.timestamp || Date.now()),
+      country: row.country || null,
+      path: row.properties?.path || null,
+      assetKey: null,
+      assetLabel: null
+    }))
+  };
+}
+function normalizeTrackEvent(track = {}, mapping) {
+  return {
+    id: `${track.session_id || track.user_id || track.timestamp || Date.now()}-${track.event || "track"}`,
+    event: String(track.event || ""),
+    properties: track.properties || {},
+    userId: track.user_id || null,
+    sessionId: track.session_id || null,
+    timestamp: Number(track.timestamp || Date.now()),
+    country: track.country || null,
+    path: track.properties?.path || null,
+    assetKey: mapping.assetKey,
+    assetLabel: mapping.label
+  };
+}
+function applySnapshotToAssetState(currentState, snapshot, mapping, now = Date.now()) {
+  const normalized = normalizeLiveSnapshot(snapshot);
+  return {
+    ...createEmptyAssetState(mapping, now),
+    ...currentState,
+    ...mapping,
+    status: "live",
+    lastUpdatedAt: now,
+    lastSnapshotAt: normalized.timestamp,
+    lastPolledAt: now,
+    activeVisitors: normalized.activeVisitors,
+    activeSessions: normalized.activeSessions,
+    eventsPerMinute: normalized.eventsPerMinute,
+    topPages: normalized.topPages,
+    topEvents: normalized.topEvents,
+    countries: normalized.countries,
+    recentEvents: normalized.recentEvents.map((event) => ({
+      ...event,
+      assetKey: mapping.assetKey,
+      assetLabel: mapping.label
+    })),
+    errors: []
+  };
+}
+function applyTrackEventToAssetState(currentState, rawTrackEvent, mapping, now = Date.now()) {
+  const state = currentState || createEmptyAssetState(mapping, now);
+  const trackEvent = normalizeTrackEvent(rawTrackEvent, mapping);
+  const next = {
+    ...state,
+    ...mapping,
+    status: state.status === "idle" ? "streaming" : state.status,
+    lastUpdatedAt: now,
+    lastHotCountry: trackEvent.country || state.lastHotCountry,
+    recentEvents: [trackEvent, ...state.recentEvents].slice(0, 12)
+  };
+  if (trackEvent.path) {
+    const topPages = [...next.topPages];
+    const existing = topPages.find((row) => row.path === trackEvent.path);
+    if (existing) existing.visitors += 1;
+    else topPages.push({ path: trackEvent.path, visitors: 1 });
+    next.topPages = sortCountRows(topPages, "visitors").slice(0, 10);
+  }
+  if (trackEvent.event) {
+    const topEvents = [...next.topEvents];
+    const existing = topEvents.find((row) => row.event === trackEvent.event);
+    if (existing) existing.count += 1;
+    else topEvents.push({ event: trackEvent.event, count: 1 });
+    next.topEvents = sortCountRows(topEvents, "count").slice(0, 10);
+  }
+  if (trackEvent.country) {
+    const countries = [...next.countries];
+    const existing = countries.find((row) => row.country === trackEvent.country);
+    if (existing) {
+      existing.events += 1;
+      if (trackEvent.userId && existing.visitors === 0) existing.visitors = 1;
+      if (trackEvent.sessionId && existing.sessions === 0) existing.sessions = 1;
+    } else {
+      countries.push({
+        country: trackEvent.country,
+        visitors: trackEvent.userId ? 1 : 0,
+        sessions: trackEvent.sessionId ? 1 : 0,
+        events: 1
+      });
+    }
+    next.countries = sortCountries(countries).slice(0, 12);
+  }
+  next.eventsPerMinute = Math.max(next.eventsPerMinute, next.topEvents.reduce((sum, row) => sum + row.count, 0));
+  return next;
+}
+function createSnoozeExpiry(minutes = DEFAULT_SNOOZE_MINUTES, now = Date.now()) {
+  return now + clampNumber(minutes, 1, 240, DEFAULT_SNOOZE_MINUTES) * 6e4;
+}
+function isSnoozed(assetKey, snoozes = {}, now = Date.now()) {
+  const snoozeUntil = Number(snoozes[assetKey] || 0);
+  return Number.isFinite(snoozeUntil) && snoozeUntil > now;
+}
+function validateEnabledMappings(mappings = []) {
+  const enabled = mappings.filter((mapping) => mapping.enabled !== false);
+  const warnings = [];
+  const errors = [];
+  if (enabled.length > MAX_ENABLED_ASSET_STREAMS) {
+    errors.push(`Enable at most ${MAX_ENABLED_ASSET_STREAMS} assets at once because Agent Analytics live streams are capped per account.`);
+  }
+  const byProject = /* @__PURE__ */ new Map();
+  for (const mapping of enabled) {
+    if (!mapping.agentAnalyticsProject) {
+      errors.push(`Asset "${mapping.label}" is missing an Agent Analytics project.`);
+      continue;
+    }
+    const count = byProject.get(mapping.agentAnalyticsProject) || 0;
+    byProject.set(mapping.agentAnalyticsProject, count + 1);
+  }
+  for (const [project, count] of byProject.entries()) {
+    if (count > 1) {
+      warnings.push(`Project "${project}" is mapped multiple times. /live snapshots are project-scoped, so duplicate mappings can mirror the same activity.`);
+    }
+  }
+  return { warnings, errors };
+}
+function buildCompanyLiveState({ settings, auth, assets, snoozes = {}, now = Date.now() }) {
+  const liveState = createEmptyCompanyLiveState();
+  const visibleAssets = [];
+  const topPagesMap = /* @__PURE__ */ new Map();
+  const topEventsMap = /* @__PURE__ */ new Map();
+  const countryMap = /* @__PURE__ */ new Map();
+  const recentEvents = [];
+  let activeVisitors = 0;
+  let activeSessions = 0;
+  let eventsPerMinute = 0;
+  for (const asset of assets) {
+    if (isSnoozed(asset.assetKey, snoozes, now)) continue;
+    visibleAssets.push(asset);
+    activeVisitors += asset.activeVisitors || 0;
+    activeSessions += asset.activeSessions || 0;
+    eventsPerMinute += asset.eventsPerMinute || 0;
+    for (const page of asset.topPages || []) {
+      const current = topPagesMap.get(page.path) || 0;
+      topPagesMap.set(page.path, current + (page.visitors || 0));
+    }
+    for (const event of asset.topEvents || []) {
+      const current = topEventsMap.get(event.event) || 0;
+      topEventsMap.set(event.event, current + (event.count || 0));
+    }
+    for (const country of asset.countries || []) {
+      const current = countryMap.get(country.country) || { country: country.country, visitors: 0, sessions: 0, events: 0 };
+      current.visitors += country.visitors || 0;
+      current.sessions += country.sessions || 0;
+      current.events += country.events || 0;
+      countryMap.set(country.country, current);
+    }
+    for (const event of asset.recentEvents || []) {
+      recentEvents.push(event);
+    }
+  }
+  const warnings = validateEnabledMappings(settings.monitoredAssets).warnings;
+  const countries = sortCountries(Array.from(countryMap.values())).slice(0, 12);
+  const sortedAssets = [...visibleAssets].sort((left, right) => {
+    if ((right.eventsPerMinute || 0) !== (left.eventsPerMinute || 0)) return (right.eventsPerMinute || 0) - (left.eventsPerMinute || 0);
+    if ((right.activeVisitors || 0) !== (left.activeVisitors || 0)) return (right.activeVisitors || 0) - (left.activeVisitors || 0);
+    return String(left.label || "").localeCompare(String(right.label || ""));
+  });
+  liveState.generatedAt = now;
+  liveState.pluginEnabled = settings.pluginEnabled !== false;
+  liveState.authStatus = auth.status;
+  liveState.tier = auth.tier;
+  liveState.account = auth.accountSummary;
+  liveState.connection = {
+    status: auth.status === "connected" ? "live" : auth.status === "error" ? "error" : "idle",
+    label: auth.status === "connected" ? "Connected" : auth.status === "error" ? "Attention needed" : "Not connected",
+    detail: auth.status === "connected" ? `Showing ${sortedAssets.length} visible asset${sortedAssets.length === 1 ? "" : "s"} from the current live window.` : auth.lastError || "Connect Agent Analytics from settings to start the live feed."
+  };
+  liveState.metrics = {
+    activeVisitors,
+    activeSessions,
+    eventsPerMinute,
+    assetsConfigured: settings.monitoredAssets.length,
+    assetsVisible: sortedAssets.length,
+    countriesTracked: countries.length
+  };
+  liveState.world = {
+    hotCountry: sortedAssets.find((asset) => asset.lastHotCountry)?.lastHotCountry || countries[0]?.country || null,
+    countries
+  };
+  liveState.evidence = {
+    topPages: sortCountRows(
+      Array.from(topPagesMap.entries()).map(([path, visitors]) => ({ path, visitors })),
+      "visitors"
+    ).slice(0, 10),
+    topEvents: sortCountRows(
+      Array.from(topEventsMap.entries()).map(([event, count]) => ({ event, count })),
+      "count"
+    ).slice(0, 10),
+    recentEvents: recentEvents.sort((left, right) => (right.timestamp || 0) - (left.timestamp || 0)).slice(0, 20),
+    countries
+  };
+  liveState.assets = sortedAssets;
+  liveState.snoozedAssets = Object.keys(snoozes).filter((assetKey) => isSnoozed(assetKey, snoozes, now));
+  liveState.warnings = warnings;
+  return liveState;
+}
+function deriveWidgetSummary(companyLiveState) {
+  return {
+    connection: companyLiveState.connection,
+    tier: companyLiveState.tier,
+    metrics: companyLiveState.metrics,
+    topAsset: companyLiveState.assets[0] || null,
+    hotCountry: companyLiveState.world.hotCountry,
+    warnings: companyLiveState.warnings
+  };
+}
+
+// src/shared/agent-analytics-client.js
+function createJsonHeaders(auth) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (auth?.access_token) headers.Authorization = `Bearer ${auth.access_token}`;
+  else if (auth?.api_key) headers["X-API-Key"] = auth.api_key;
+  return headers;
+}
+function buildQuery(params) {
+  return Object.entries(params).filter(([, value]) => value !== null && value !== void 0 && value !== "").map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+function parseSseEvent(rawEvent) {
+  const event = {
+    event: "message",
+    data: "",
+    comment: null
+  };
+  const lines = rawEvent.split(/\r?\n/);
+  for (const line of lines) {
+    if (!line) continue;
+    if (line.startsWith(":")) {
+      event.comment = line.slice(1).trim();
+      continue;
+    }
+    const separatorIndex = line.indexOf(":");
+    const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+    const value = separatorIndex === -1 ? "" : line.slice(separatorIndex + 1).trimStart();
+    if (field === "event") event.event = value;
+    if (field === "data") event.data = event.data ? `${event.data}
+${value}` : value;
+  }
+  return event;
+}
+var AgentAnalyticsClient = class {
+  constructor({
+    auth = null,
+    baseUrl = DEFAULT_BASE_URL,
+    fetchImpl = globalThis.fetch,
+    onAuthUpdate = null
+  } = {}) {
+    this.auth = auth ? { ...auth } : null;
+    this.baseUrl = baseUrl;
+    this.fetchImpl = fetchImpl;
+    this.onAuthUpdate = onAuthUpdate;
+  }
+  setAuth(auth) {
+    this.auth = auth ? { ...auth } : null;
+  }
+  async request(method, path, body, { retryOnRefresh = true } = {}) {
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method,
+      headers: createJsonHeaders(this.auth),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const data = await response.json().catch(() => ({}));
+    if (response.status === 401 && retryOnRefresh && this.auth?.refresh_token) {
+      const refreshed = await this.refreshAgentSession().catch(() => null);
+      if (refreshed?.access_token) {
+        return this.request(method, path, body, { retryOnRefresh: false });
+      }
+    }
+    if (!response.ok) {
+      throw new Error(data.message || data.error || `HTTP ${response.status}`);
+    }
+    return data;
+  }
+  async startPaperclipAuth({ companyId, label } = {}) {
+    return this.request(
+      "POST",
+      "/agent-sessions/start",
+      {
+        mode: "detached",
+        client_type: "paperclip",
+        client_name: PLUGIN_DISPLAY_NAME,
+        client_instance_id: companyId || null,
+        label: label || `Paperclip Company ${companyId || ""}`.trim(),
+        scopes: AGENT_SESSION_SCOPES,
+        metadata: {
+          platform: "paperclip",
+          plugin_id: PLUGIN_ID,
+          company_id: companyId || null
+        }
+      },
+      { retryOnRefresh: false }
+    );
+  }
+  async exchangeAgentSession(authRequestId, exchangeCode) {
+    return this.request(
+      "POST",
+      "/agent-sessions/exchange",
+      {
+        auth_request_id: authRequestId,
+        exchange_code: exchangeCode
+      },
+      { retryOnRefresh: false }
+    );
+  }
+  async refreshAgentSession() {
+    if (!this.auth?.refresh_token) {
+      throw new Error("No refresh token available");
+    }
+    const refreshed = await this.request(
+      "POST",
+      "/agent-sessions/refresh",
+      {
+        refresh_token: this.auth.refresh_token
+      },
+      { retryOnRefresh: false }
+    );
+    this.auth = {
+      ...this.auth,
+      ...refreshed.agent_session
+    };
+    this.onAuthUpdate?.(this.auth);
+    return this.auth;
+  }
+  async listProjects() {
+    return this.request("GET", "/projects");
+  }
+  async getLive(project, { window } = {}) {
+    const query = buildQuery({ project, window });
+    return this.request("GET", `/live?${query}`);
+  }
+  async subscribeToStream({ project, filter, signal, onConnected, onTrack, onComment }) {
+    const query = buildQuery({
+      project,
+      filter
+    });
+    const response = await this.fetchImpl(`${this.baseUrl}/stream?${query}`, {
+      method: "GET",
+      headers: createJsonHeaders(this.auth),
+      signal
+    });
+    if (!response.ok || !response.body) {
+      const payload = await response.text().catch(() => "");
+      throw new Error(payload || `Stream failed with HTTP ${response.status}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        const rawEvent = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const event = parseSseEvent(rawEvent);
+        if (event.comment) {
+          onComment?.(event.comment);
+        }
+        if (event.data) {
+          let parsed = {};
+          try {
+            parsed = JSON.parse(event.data);
+          } catch {
+            parsed = { raw: event.data };
+          }
+          if (event.event === "connected") onConnected?.(parsed);
+          if (event.event === "track") onTrack?.(parsed);
+        }
+        boundary = buffer.indexOf("\n\n");
+      }
+    }
+  }
+};
+
+// src/worker/paperclip.js
+async function registerDataHandler(ctx, key, handler) {
+  if (ctx?.data?.register) {
+    return ctx.data.register(key, handler);
+  }
+  if (ctx?.registerData) {
+    return ctx.registerData(key, handler);
+  }
+  throw new Error(`Paperclip data registration is unavailable for key "${key}"`);
+}
+async function registerActionHandler(ctx, key, handler) {
+  if (ctx?.actions?.register) {
+    return ctx.actions.register(key, handler);
+  }
+  if (ctx?.registerAction) {
+    return ctx.registerAction(key, handler);
+  }
+  throw new Error(`Paperclip action registration is unavailable for key "${key}"`);
+}
+async function openLiveChannel(ctx, companyId) {
+  if (!ctx?.streams?.open) return;
+  await ctx.streams.open(LIVE_STREAM_CHANNEL, companyId);
+}
+async function emitLiveState(ctx, companyId, payload) {
+  if (!ctx?.streams?.emit) return;
+  await ctx.streams.emit(LIVE_STREAM_CHANNEL, payload);
+}
+async function closeLiveChannel(ctx, companyId) {
+  if (!ctx?.streams?.close) return;
+  await ctx.streams.close(LIVE_STREAM_CHANNEL, companyId);
+}
+
+// src/worker/state.js
+function createScope(companyId) {
+  return {
+    scopeKind: "company",
+    scopeId: companyId,
+    namespace: STATE_NAMESPACE
+  };
+}
+async function getValue(ctx, companyId, key, fallbackValue) {
+  if (!ctx?.state?.get) return fallbackValue;
+  const value = await ctx.state.get({
+    ...createScope(String(companyId)),
+    stateKey: key
+  });
+  return value ?? fallbackValue;
+}
+async function setValue(ctx, companyId, key, value) {
+  if (!ctx?.state?.set) return value;
+  await ctx.state.set({
+    ...createScope(String(companyId)),
+    stateKey: key,
+    value
+  });
+  return value;
+}
+async function loadSettings(ctx, companyId) {
+  return getValue(ctx, companyId, "config", createDefaultSettings());
+}
+async function saveSettings(ctx, companyId, settings) {
+  return setValue(ctx, companyId, "config", settings);
+}
+async function loadAuthState(ctx, companyId) {
+  return getValue(ctx, companyId, "auth", createDefaultAuthState());
+}
+async function saveAuthState(ctx, companyId, authState) {
+  return setValue(ctx, companyId, "auth", authState);
+}
+async function loadSnoozes(ctx, companyId) {
+  return getValue(ctx, companyId, "snoozes", createDefaultSnoozeState());
+}
+async function saveSnoozes(ctx, companyId, snoozes) {
+  return setValue(ctx, companyId, "snoozes", snoozes);
+}
+
+// src/worker/service.js
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function serializeAccount(account) {
+  if (!account) return null;
+  return {
+    id: account.id,
+    email: account.email,
+    githubLogin: account.github_login || null,
+    googleName: account.google_name || null
+  };
+}
+function toPublicAuthState(auth) {
+  return {
+    status: auth.status,
+    mode: auth.mode,
+    tier: auth.tier,
+    accountSummary: auth.accountSummary,
+    accessExpiresAt: auth.accessExpiresAt,
+    refreshExpiresAt: auth.refreshExpiresAt,
+    pendingAuthRequest: auth.pendingAuthRequest,
+    lastValidatedAt: auth.lastValidatedAt,
+    lastError: auth.lastError,
+    connected: Boolean(auth.accessToken)
+  };
+}
+var PaperclipLiveAnalyticsService = class {
+  constructor(ctx, { fetchImpl = globalThis.fetch } = {}) {
+    this.ctx = ctx;
+    this.fetchImpl = fetchImpl;
+    this.runtimes = /* @__PURE__ */ new Map();
+  }
+  async register() {
+    await registerDataHandler(this.ctx, DATA_KEYS.livePageLoad, (input) => this.loadLivePage(input));
+    await registerDataHandler(this.ctx, DATA_KEYS.liveWidgetLoad, (input) => this.loadLiveWidget(input));
+    await registerDataHandler(this.ctx, DATA_KEYS.settingsLoad, (input) => this.loadSettingsData(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.authStart, (input) => this.startAuth(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.authComplete, (input) => this.completeAuth(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.authReconnect, (input) => this.reconnectAuth(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.authDisconnect, (input) => this.disconnectAuth(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.settingsSave, (input) => this.savePluginSettings(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.mappingUpsert, (input) => this.upsertMapping(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.mappingRemove, (input) => this.removeMapping(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.assetSnooze, (input) => this.snoozeAsset(input));
+    await registerActionHandler(this.ctx, ACTION_KEYS.assetUnsnooze, (input) => this.unsnoozeAsset(input));
+  }
+  async shutdown() {
+    for (const [companyId] of this.runtimes.entries()) {
+      await this.stopRuntime(companyId);
+    }
+  }
+  async loadLivePage({ companyId }) {
+    const liveState = await this.ensureLiveState(companyId);
+    return liveState;
+  }
+  async loadLiveWidget({ companyId }) {
+    const liveState = await this.ensureLiveState(companyId);
+    return deriveWidgetSummary(liveState);
+  }
+  async loadSettingsData({ companyId }) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const auth = await loadAuthState(this.ctx, companyId);
+    const validation = validateEnabledMappings(settings.monitoredAssets);
+    const projects = await this.listProjectsForCompany(companyId).catch((error) => ({
+      projects: [],
+      tier: auth.tier,
+      error: error.message
+    }));
+    return {
+      settings,
+      auth: toPublicAuthState(auth),
+      discoveredProjects: projects.projects || [],
+      validation,
+      projectListError: projects.error || null
+    };
+  }
+  async startAuth({ companyId, label }) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const auth = await loadAuthState(this.ctx, companyId);
+    const client = this.createClient(companyId, settings, auth);
+    const started = await client.startPaperclipAuth({ companyId, label });
+    const nextAuth = {
+      ...auth,
+      status: "pending",
+      lastError: null,
+      pendingAuthRequest: {
+        authRequestId: started.auth_request_id,
+        authorizeUrl: started.authorize_url,
+        approvalCode: started.approval_code,
+        pollToken: started.poll_token,
+        expiresAt: started.expires_at
+      }
+    };
+    await saveAuthState(this.ctx, companyId, nextAuth);
+    return {
+      auth: toPublicAuthState(nextAuth)
+    };
+  }
+  async completeAuth({ companyId, authRequestId, exchangeCode }) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const auth = await loadAuthState(this.ctx, companyId);
+    const requestId = authRequestId || auth.pendingAuthRequest?.authRequestId;
+    if (!requestId || !exchangeCode) {
+      throw new Error("authRequestId and exchangeCode are required");
+    }
+    const client = this.createClient(companyId, settings, auth);
+    const exchanged = await client.exchangeAgentSession(requestId, exchangeCode);
+    const nextAuth = {
+      mode: "agent_session",
+      accessToken: exchanged.agent_session.access_token,
+      refreshToken: exchanged.agent_session.refresh_token,
+      accessExpiresAt: exchanged.agent_session.access_expires_at,
+      refreshExpiresAt: exchanged.agent_session.refresh_expires_at,
+      accountSummary: serializeAccount(exchanged.account),
+      tier: exchanged.account?.tier || null,
+      status: "connected",
+      pendingAuthRequest: null,
+      lastValidatedAt: Date.now(),
+      lastError: null
+    };
+    await saveAuthState(this.ctx, companyId, nextAuth);
+    await this.ensureLiveState(companyId, { forceSync: true });
+    return this.loadSettingsData({ companyId });
+  }
+  async reconnectAuth({ companyId }) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const auth = await loadAuthState(this.ctx, companyId);
+    if (!auth.refreshToken) {
+      return this.startAuth({ companyId });
+    }
+    const client = this.createClient(companyId, settings, auth);
+    const refreshed = await client.refreshAgentSession();
+    const nextAuth = {
+      ...auth,
+      accessToken: refreshed.access_token,
+      refreshToken: refreshed.refresh_token || auth.refreshToken,
+      accessExpiresAt: refreshed.access_expires_at,
+      refreshExpiresAt: refreshed.refresh_expires_at || auth.refreshExpiresAt,
+      status: "connected",
+      lastValidatedAt: Date.now(),
+      lastError: null
+    };
+    await saveAuthState(this.ctx, companyId, nextAuth);
+    await this.ensureLiveState(companyId, { forceSync: true });
+    return this.loadSettingsData({ companyId });
+  }
+  async disconnectAuth({ companyId }) {
+    const auth = await loadAuthState(this.ctx, companyId);
+    const nextAuth = {
+      ...auth,
+      accessToken: null,
+      refreshToken: null,
+      accessExpiresAt: null,
+      refreshExpiresAt: null,
+      status: "disconnected",
+      pendingAuthRequest: null,
+      lastError: null
+    };
+    await saveAuthState(this.ctx, companyId, nextAuth);
+    await this.stopRuntime(companyId);
+    return this.loadSettingsData({ companyId });
+  }
+  async savePluginSettings({ companyId, settings: partialSettings = {} }) {
+    const currentSettings = await loadSettings(this.ctx, companyId);
+    const nextSettings = {
+      ...currentSettings,
+      agentAnalyticsBaseUrl: partialSettings.agentAnalyticsBaseUrl || currentSettings.agentAnalyticsBaseUrl || DEFAULT_BASE_URL,
+      liveWindowSeconds: clampLiveWindowSeconds(partialSettings.liveWindowSeconds ?? currentSettings.liveWindowSeconds),
+      pollIntervalSeconds: clampPollIntervalSeconds(partialSettings.pollIntervalSeconds ?? currentSettings.pollIntervalSeconds),
+      pluginEnabled: partialSettings.pluginEnabled ?? currentSettings.pluginEnabled
+    };
+    const validation = validateEnabledMappings(nextSettings.monitoredAssets);
+    if (validation.errors.length > 0) {
+      throw new Error(validation.errors.join(" "));
+    }
+    await saveSettings(this.ctx, companyId, nextSettings);
+    await this.ensureLiveState(companyId, { forceSync: true });
+    return this.loadSettingsData({ companyId });
+  }
+  async upsertMapping({ companyId, mapping }) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const normalized = normalizeAssetMapping(mapping);
+    const monitoredAssets = [...settings.monitoredAssets];
+    const existingIndex = monitoredAssets.findIndex((entry) => entry.assetKey === normalized.assetKey);
+    if (existingIndex === -1) monitoredAssets.push(normalized);
+    else monitoredAssets.splice(existingIndex, 1, normalized);
+    const validation = validateEnabledMappings(monitoredAssets);
+    if (validation.errors.length > 0) {
+      throw new Error(validation.errors.join(" "));
+    }
+    const nextSettings = {
+      ...settings,
+      monitoredAssets
+    };
+    await saveSettings(this.ctx, companyId, nextSettings);
+    await this.ensureLiveState(companyId, { forceSync: true });
+    return this.loadSettingsData({ companyId });
+  }
+  async removeMapping({ companyId, assetKey }) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const nextSettings = {
+      ...settings,
+      monitoredAssets: settings.monitoredAssets.filter((mapping) => mapping.assetKey !== assetKey)
+    };
+    await saveSettings(this.ctx, companyId, nextSettings);
+    await this.ensureLiveState(companyId, { forceSync: true });
+    return this.loadSettingsData({ companyId });
+  }
+  async snoozeAsset({ companyId, assetKey, minutes = DEFAULT_SNOOZE_MINUTES }) {
+    const snoozes = await loadSnoozes(this.ctx, companyId);
+    const nextSnoozes = {
+      ...snoozes,
+      [assetKey]: createSnoozeExpiry(minutes)
+    };
+    await saveSnoozes(this.ctx, companyId, nextSnoozes);
+    const liveState = await this.ensureLiveState(companyId);
+    return {
+      snoozes: nextSnoozes,
+      liveState
+    };
+  }
+  async unsnoozeAsset({ companyId, assetKey }) {
+    const snoozes = await loadSnoozes(this.ctx, companyId);
+    const nextSnoozes = { ...snoozes };
+    delete nextSnoozes[assetKey];
+    await saveSnoozes(this.ctx, companyId, nextSnoozes);
+    const liveState = await this.ensureLiveState(companyId);
+    return {
+      snoozes: nextSnoozes,
+      liveState
+    };
+  }
+  async ensureLiveState(companyId, { forceSync = false } = {}) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const auth = await loadAuthState(this.ctx, companyId);
+    const snoozes = await loadSnoozes(this.ctx, companyId);
+    const runtime = this.getRuntime(companyId);
+    if (forceSync) {
+      await this.syncRuntime(companyId, settings, auth, runtime);
+    } else if (!runtime.lastState) {
+      await this.syncRuntime(companyId, settings, auth, runtime);
+    }
+    const assetStates = settings.monitoredAssets.map((mapping) => {
+      const normalized = normalizeAssetMapping(mapping);
+      return runtime.assetStates.get(normalized.assetKey) || createEmptyAssetState(normalized);
+    });
+    const liveState = buildCompanyLiveState({
+      settings,
+      auth,
+      assets: assetStates,
+      snoozes
+    });
+    runtime.lastState = liveState;
+    return liveState;
+  }
+  async syncRuntime(companyId, settings, auth, runtime) {
+    const mappings = settings.monitoredAssets.map(normalizeAssetMapping);
+    const validation = validateEnabledMappings(mappings);
+    if (!settings.pluginEnabled || !auth.accessToken || validation.errors.length > 0) {
+      auth.status = validation.errors.length > 0 ? "error" : auth.status;
+      if (validation.errors.length > 0) auth.lastError = validation.errors.join(" ");
+      await saveAuthState(this.ctx, companyId, auth);
+      await this.stopRuntime(companyId, { keepState: true });
+      return;
+    }
+    await openLiveChannel(this.ctx, companyId);
+    for (const mapping of mappings) {
+      const current = runtime.assetStates.get(mapping.assetKey) || createEmptyAssetState(mapping);
+      runtime.assetStates.set(mapping.assetKey, {
+        ...current,
+        ...mapping
+      });
+    }
+    for (const assetKey of Array.from(runtime.assetStates.keys())) {
+      if (!mappings.find((mapping) => mapping.assetKey === assetKey)) {
+        runtime.assetStates.delete(assetKey);
+      }
+    }
+    const enabledMappings = mappings.filter((mapping) => mapping.enabled !== false).slice(0, MAX_ENABLED_ASSET_STREAMS);
+    const groupedMappings = /* @__PURE__ */ new Map();
+    for (const mapping of enabledMappings) {
+      const signature = mappingSignature(mapping);
+      const group = groupedMappings.get(signature) || [];
+      group.push(mapping);
+      groupedMappings.set(signature, group);
+    }
+    for (const [signature, streamRuntime] of runtime.streams.entries()) {
+      if (!groupedMappings.has(signature)) {
+        streamRuntime.controller.abort();
+        runtime.streams.delete(signature);
+      }
+    }
+    for (const [signature, group] of groupedMappings.entries()) {
+      const existing = runtime.streams.get(signature);
+      if (existing) {
+        existing.mappings = group;
+      } else {
+        runtime.streams.set(signature, this.startStreamLoop(companyId, settings, auth, group));
+      }
+    }
+    for (const mapping of enabledMappings) {
+      const poller = runtime.pollers.get(mapping.assetKey);
+      if (poller) {
+        clearInterval(poller);
+      }
+      const intervalId = setInterval(() => {
+        this.refreshSnapshot(companyId, mapping).catch((error) => this.recordAssetError(companyId, mapping.assetKey, error));
+      }, settings.pollIntervalSeconds * 1e3);
+      runtime.pollers.set(mapping.assetKey, intervalId);
+      await this.refreshSnapshot(companyId, mapping);
+    }
+    for (const [assetKey, intervalId] of runtime.pollers.entries()) {
+      if (!enabledMappings.find((mapping) => mapping.assetKey === assetKey)) {
+        clearInterval(intervalId);
+        runtime.pollers.delete(assetKey);
+      }
+    }
+  }
+  createClient(companyId, settings, auth) {
+    return new AgentAnalyticsClient({
+      auth: {
+        access_token: auth.accessToken,
+        refresh_token: auth.refreshToken
+      },
+      baseUrl: settings.agentAnalyticsBaseUrl || DEFAULT_BASE_URL,
+      fetchImpl: this.fetchImpl,
+      onAuthUpdate: async (nextAuth) => {
+        const current = await loadAuthState(this.ctx, companyId);
+        await saveAuthState(this.ctx, companyId, {
+          ...current,
+          accessToken: nextAuth.access_token,
+          refreshToken: nextAuth.refresh_token || current.refreshToken,
+          accessExpiresAt: nextAuth.access_expires_at,
+          refreshExpiresAt: nextAuth.refresh_expires_at || current.refreshExpiresAt,
+          status: "connected",
+          lastValidatedAt: Date.now(),
+          lastError: null
+        });
+      }
+    });
+  }
+  getRuntime(companyId) {
+    let runtime = this.runtimes.get(companyId);
+    if (!runtime) {
+      runtime = {
+        pollers: /* @__PURE__ */ new Map(),
+        streams: /* @__PURE__ */ new Map(),
+        assetStates: /* @__PURE__ */ new Map(),
+        lastState: null
+      };
+      this.runtimes.set(companyId, runtime);
+    }
+    return runtime;
+  }
+  startStreamLoop(companyId, settings, auth, mappings) {
+    const controller = new AbortController();
+    const runtime = {
+      controller,
+      mappings,
+      run: (async () => {
+        while (!controller.signal.aborted) {
+          try {
+            const currentSettings = await loadSettings(this.ctx, companyId);
+            const currentAuth = await loadAuthState(this.ctx, companyId);
+            const client = this.createClient(companyId, currentSettings, currentAuth);
+            const primaryMapping = mappings[0];
+            await client.subscribeToStream({
+              project: primaryMapping.agentAnalyticsProject,
+              filter: primaryMapping.primaryHostname ? `hostname:${primaryMapping.primaryHostname}` : null,
+              signal: controller.signal,
+              onTrack: async (track) => {
+                await this.applyTrackEvent(companyId, mappings, track);
+              }
+            });
+          } catch (error) {
+            if (!controller.signal.aborted) {
+              for (const mapping of mappings) {
+                await this.recordAssetError(companyId, mapping.assetKey, error);
+              }
+              await delay(2e3);
+            }
+          }
+        }
+      })()
+    };
+    return runtime;
+  }
+  async refreshSnapshot(companyId, mapping) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const auth = await loadAuthState(this.ctx, companyId);
+    const client = this.createClient(companyId, settings, auth);
+    const snapshot = await client.getLive(mapping.agentAnalyticsProject, {
+      window: settings.liveWindowSeconds
+    });
+    const runtime = this.getRuntime(companyId);
+    const currentState = runtime.assetStates.get(mapping.assetKey) || createEmptyAssetState(mapping);
+    runtime.assetStates.set(mapping.assetKey, applySnapshotToAssetState(currentState, snapshot, mapping));
+    await this.publish(companyId);
+  }
+  async applyTrackEvent(companyId, mappings, track) {
+    const runtime = this.getRuntime(companyId);
+    for (const mapping of mappings) {
+      const currentState = runtime.assetStates.get(mapping.assetKey) || createEmptyAssetState(mapping);
+      runtime.assetStates.set(mapping.assetKey, applyTrackEventToAssetState(currentState, track, mapping));
+    }
+    await this.publish(companyId);
+  }
+  async recordAssetError(companyId, assetKey, error) {
+    const runtime = this.getRuntime(companyId);
+    const current = runtime.assetStates.get(assetKey);
+    if (!current) return;
+    runtime.assetStates.set(assetKey, {
+      ...current,
+      status: "error",
+      errors: [error.message || String(error)],
+      lastUpdatedAt: Date.now()
+    });
+    const auth = await loadAuthState(this.ctx, companyId);
+    await saveAuthState(this.ctx, companyId, {
+      ...auth,
+      status: "error",
+      lastError: error.message || String(error)
+    });
+    await this.publish(companyId);
+  }
+  async publish(companyId) {
+    const liveState = await this.ensureLiveState(companyId);
+    await emitLiveState(this.ctx, companyId, liveState);
+  }
+  async listProjectsForCompany(companyId) {
+    const settings = await loadSettings(this.ctx, companyId);
+    const auth = await loadAuthState(this.ctx, companyId);
+    if (!auth.accessToken) {
+      return { projects: [], tier: auth.tier, error: null };
+    }
+    const client = this.createClient(companyId, settings, auth);
+    return client.listProjects();
+  }
+  async stopRuntime(companyId, { keepState = false } = {}) {
+    const runtime = this.runtimes.get(companyId);
+    if (!runtime) return;
+    for (const intervalId of runtime.pollers.values()) {
+      clearInterval(intervalId);
+    }
+    runtime.pollers.clear();
+    for (const streamRuntime of runtime.streams.values()) {
+      streamRuntime.controller.abort();
+    }
+    runtime.streams.clear();
+    if (!keepState) {
+      runtime.assetStates.clear();
+      runtime.lastState = null;
+      this.runtimes.delete(companyId);
+    }
+    await closeLiveChannel(this.ctx, companyId);
+  }
+};
+
+// src/paperclip/worker-entry.js
+var service = null;
+var plugin = definePlugin({
+  async setup(ctx) {
+    service = new PaperclipLiveAnalyticsService(ctx, {
+      fetchImpl: ctx.http?.fetch?.bind(ctx.http) || globalThis.fetch
+    });
+    await service.register();
+  },
+  async onHealth() {
+    return {
+      status: "ok",
+      details: {
+        pluginId: PLUGIN_ID
+      }
+    };
+  },
+  async onShutdown() {
+    await service?.shutdown?.();
+  }
+});
+var worker_entry_default = plugin;
+runWorker(plugin, import.meta.url);
+export {
+  worker_entry_default as default
+};