spine-framework-cortex 0.2.6 → 0.2.7

package/manifest.json

@@ -2,7 +2,8 @@
   "name": "Cortex",
   "slug": "cortex",
   "description": "Unified workspace for CRM, Support, Community, and Knowledge Base",
-  "version": "1.0.0",
+  "version": "0.2.7",
+  "app_type": "full",
   "required_roles": ["support"],
   "routes": [
     "/cortex",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-framework-cortex",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "private": false,
   "description": "Cortex — AI-powered support, CRM, and knowledge base app for Spine Framework",
   "keywords": ["spine-framework", "crm", "support", "knowledge-base", "community"],
@@ -15,13 +15,17 @@
     "seed/",
     "pages/",
     "components/",
-    "api/",
+    "functions/",
     "hooks/",
+    "public/",
     "README.md"
   ],
+  "scripts": {
+    "validate": "npx spine-framework validate-app ."
+  },
   "spine": {
-    "app_slug": "cortex",
-    "entry_point": "./index.tsx",
-    "manifest": "./manifest.json"
+    "type": "app",
+    "slug": "cortex",
+    "manifestPath": "manifest.json"
   }
 }

package/public/spine-tracker.js

@@ -0,0 +1,255 @@
+/**
+ * Spine Marketing Site Tracker
+ * Tracks anonymous and identified visitors across spine-framework.com
+ * 
+ * Usage:
+ * <script src="https://portal.spine-framework.com/spine-tracker.js" data-api-key="YOUR_KEY"></script>
+ * <script>
+ *   spineTracker.init({
+ *     apiUrl: 'https://portal.spine-framework.com/.netlify/functions/integration-routes?slug=funnel-signal',
+ *     trackPageViews: true,
+ *     trackClicks: true
+ *   });
+ * </script>
+ */
+
+(function(window) {
+  'use strict';
+
+  const COOKIE_NAME_ANON = 'spine_anonymous_id';
+  const COOKIE_NAME_IDENTITY = 'spine_identity';
+  const STORAGE_KEY_ANON = 'spine_anonymous_id';
+  const COOKIE_DOMAIN = '.spine-framework.com';
+  const COOKIE_EXPIRY_DAYS = 365;
+
+  class SpineTracker {
+    constructor() {
+      this.config = {
+        apiUrl: '',
+        apiKey: '',
+        trackPageViews: true,
+        trackClicks: true,
+        debug: false
+      };
+      this.identity = null;
+      this.anonymousId = null;
+      this.sessionId = this.generateId();
+    }
+
+    generateId() {
+      if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+      }
+      return 'anon_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+    }
+
+    setCookie(name, value, days) {
+      const expires = new Date(Date.now() + days * 24 * 60 * 60 * 1000).toUTCString();
+      document.cookie = `${name}=${encodeURIComponent(JSON.stringify(value))};expires=${expires};domain=${COOKIE_DOMAIN};path=/;Secure;SameSite=Lax`;
+    }
+
+    getCookie(name) {
+      const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+      if (match) {
+        try {
+          return JSON.parse(decodeURIComponent(match[2]));
+        } catch (e) {
+          return match[2];
+        }
+      }
+      return null;
+    }
+
+    getOrCreateAnonymousId() {
+      // Try localStorage first
+      let id = localStorage.getItem(STORAGE_KEY_ANON);
+      
+      // Fallback to cookie (for Safari ITP)
+      if (!id) {
+        const cookieId = this.getCookie(COOKIE_NAME_ANON);
+        if (cookieId) {
+          id = cookieId;
+          localStorage.setItem(STORAGE_KEY_ANON, id);
+        }
+      }
+
+      // Generate new if not found
+      if (!id) {
+        id = this.generateId();
+        localStorage.setItem(STORAGE_KEY_ANON, id);
+        this.setCookie(COOKIE_NAME_ANON, id, COOKIE_EXPIRY_DAYS);
+      }
+
+      return id;
+    }
+
+    getIdentity() {
+      // Check for identity cookie
+      const identity = this.getCookie(COOKIE_NAME_IDENTITY);
+      if (identity && identity.account_id) {
+        return {
+          account_id: identity.account_id,
+          person_id: identity.person_id,
+          stage: 'identified'
+        };
+      }
+      return null;
+    }
+
+    async sendSignal(actionType, actionValue, metadata = {}) {
+      if (!this.config.apiUrl || !this.config.apiKey) {
+        console.warn('[SpineTracker] Not initialized');
+        return;
+      }
+
+      const identity = this.getIdentity();
+      const payload = {
+        source: 'mar',
+        stage: identity ? 'identified' : 'anonymous',
+        action_type: actionType,
+        action_value: actionValue,
+        session_id: this.sessionId,
+        url: window.location.href,
+        path: window.location.pathname,
+        referrer: document.referrer || null,
+        user_agent: navigator.userAgent,
+        ...metadata
+      };
+
+      if (identity) {
+        payload.account_id = identity.account_id;
+        payload.person_id = identity.person_id;
+      }
+
+      // Always include anonymous_id for session continuity
+      payload.anonymous_id = this.getOrCreateAnonymousId();
+
+      try {
+        const response = await fetch(this.config.apiUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': this.config.apiKey
+          },
+          body: JSON.stringify(payload)
+        });
+
+        if (this.config.debug) {
+          console.log('[SpineTracker] Signal sent:', payload);
+          console.log('[SpineTracker] Response:', response.status);
+        }
+      } catch (error) {
+        if (this.config.debug) {
+          console.error('[SpineTracker] Failed to send signal:', error);
+        }
+      }
+    }
+
+    trackPageView() {
+      this.sendSignal('page_view', 1, {
+        title: document.title,
+        utm_source: this.getQueryParam('utm_source'),
+        utm_medium: this.getQueryParam('utm_medium'),
+        utm_campaign: this.getQueryParam('utm_campaign')
+      });
+    }
+
+    trackClick(element, actionType, actionValue = 2) {
+      element.addEventListener('click', () => {
+        this.sendSignal(actionType, actionValue, {
+          element_id: element.id || null,
+          element_text: element.innerText?.substring(0, 100) || null
+        });
+      });
+    }
+
+    getQueryParam(name) {
+      const urlParams = new URLSearchParams(window.location.search);
+      return urlParams.get(name);
+    }
+
+    init(config) {
+      this.config = { ...this.config, ...config };
+      
+      // Get API key from script tag if not provided
+      if (!this.config.apiKey) {
+        const script = document.querySelector('script[src*="spine-tracker.js"]');
+        if (script) {
+          this.config.apiKey = script.dataset.apiKey;
+        }
+      }
+
+      // Initialize anonymous ID
+      this.anonymousId = this.getOrCreateAnonymousId();
+
+      // Check for identity
+      this.identity = this.getIdentity();
+
+      if (this.config.debug) {
+        console.log('[SpineTracker] Initialized:', {
+          anonymousId: this.anonymousId,
+          identity: this.identity,
+          sessionId: this.sessionId
+        });
+      }
+
+      // Track page view
+      if (this.config.trackPageViews) {
+        this.trackPageView();
+      }
+
+      // Setup click tracking
+      if (this.config.trackClicks) {
+        this.setupClickTracking();
+      }
+
+      return this;
+    }
+
+    setupClickTracking() {
+      // Auto-track elements with data-track attributes
+      document.addEventListener('click', (e) => {
+        const target = e.target.closest('[data-track-action]');
+        if (target) {
+          const actionType = target.dataset.trackAction;
+          const actionValue = parseInt(target.dataset.trackValue) || 2;
+          this.sendSignal(actionType, actionValue, {
+            element_id: target.id || null,
+            element_text: target.innerText?.substring(0, 100) || null
+          });
+        }
+      });
+    }
+
+    // Public API for manual tracking
+    track(actionType, actionValue, metadata) {
+      return this.sendSignal(actionType, actionValue, metadata);
+    }
+
+    // Update identity (called after login/signup)
+    setIdentity(accountId, personId) {
+      this.setCookie(COOKIE_NAME_IDENTITY, {
+        account_id: accountId,
+        person_id: personId,
+        set_at: new Date().toISOString()
+      }, COOKIE_EXPIRY_DAYS);
+      this.identity = { account_id: accountId, person_id: personId };
+    }
+
+    // Clear identity (called on logout)
+    clearIdentity() {
+      this.setCookie(COOKIE_NAME_IDENTITY, '', -1);
+      this.identity = null;
+    }
+  }
+
+  // Expose to window
+  window.SpineTracker = SpineTracker;
+  window.spineTracker = new SpineTracker();
+
+  // Auto-init if config present
+  if (window.spineTrackerConfig) {
+    window.spineTracker.init(window.spineTrackerConfig);
+  }
+
+})(window);