uac-package 1.1.0

package/lib/apiConfig.js

@@ -0,0 +1,22 @@
+/** Production UAC backend (paths like /api/domains are appended by the client). */
+const DEFAULT_UAC_API_URL = 'https://uac-backend.clay.in';
+
+function normalizeApiBaseUrl(url) {
+  let value = String(url || '').trim().replace(/\/$/, '');
+
+  if (!value) {
+    return DEFAULT_UAC_API_URL;
+  }
+
+  // Accept https://host/api — strip trailing /api to avoid /api/api/...
+  if (value.endsWith('/api')) {
+    value = value.slice(0, -4);
+  }
+
+  return value;
+}
+
+module.exports = {
+  DEFAULT_UAC_API_URL,
+  normalizeApiBaseUrl,
+};

package/lib/apiConfig.mjs

@@ -0,0 +1,15 @@
+export const DEFAULT_UAC_API_URL = 'https://uac-backend.clay.in';
+
+export function normalizeApiBaseUrl(url) {
+  let value = String(url || '').trim().replace(/\/$/, '');
+
+  if (!value) {
+    return DEFAULT_UAC_API_URL;
+  }
+
+  if (value.endsWith('/api')) {
+    value = value.slice(0, -4);
+  }
+
+  return value;
+}

package/lib/autoTrack.js

@@ -0,0 +1,56 @@
+const { init } = require('./client');
+const { resolveAppUrl, normalizeDomain } = require('./normalizeDomain');
+
+const trackedDomains = new Set();
+
+function isAutoTrackEnabled() {
+  return process.env.UAC_AUTO_TRACK !== 'false';
+}
+
+function canAutoTrack(options = {}) {
+  if (options.url || options.domain || options.name) return true;
+  if (options.port || process.env.PORT) return true;
+  return false;
+}
+
+function autoTrack(options = {}) {
+  if (!isAutoTrackEnabled()) {
+    return Promise.resolve(null);
+  }
+
+  const config = { ...options };
+
+  if (!canAutoTrack(config)) {
+    return Promise.resolve(null);
+  }
+
+  const appUrl = resolveAppUrl(config);
+  const domain = normalizeDomain(appUrl);
+
+  if (!domain) {
+    return Promise.resolve(null);
+  }
+
+  if (trackedDomains.has(domain)) {
+    return Promise.resolve({ created: false, name: domain, message: 'Already tracked' });
+  }
+
+  console.log('[UAC] Auto-tracking domain:', domain);
+
+  return init(config)
+    .then((registration) => {
+      trackedDomains.add(registration.name);
+      if (registration.created) {
+        console.log('[UAC] Domain stored:', registration.name);
+      } else {
+        console.log('[UAC] Domain already registered:', registration.name);
+      }
+      return registration;
+    })
+    .catch((error) => {
+      console.warn('[UAC] Auto-track failed:', error.message);
+      return null;
+    });
+}
+
+module.exports = { autoTrack, isAutoTrackEnabled, canAutoTrack };

package/lib/boot.js

@@ -0,0 +1,33 @@
+const { normalizeDomain, resolveAppUrl } = require('./normalizeDomain');
+const { getApiUrl, init } = require('./client');
+
+async function boot(options = {}) {
+  const port = options.port || process.env.PORT || 4001;
+  const config = { ...options, port };
+  const appUrl = resolveAppUrl(config);
+  const apiUrl = getApiUrl(config);
+  const domain = normalizeDomain(appUrl);
+
+  console.log('UAC: Registering domain...');
+  console.log('UAC: App URL:', appUrl);
+  console.log('UAC: Backend:', apiUrl);
+  console.log('UAC: Domain:', domain);
+
+  const registration = await init(config);
+
+  if (registration.created) {
+    console.log('UAC: Domain stored in database:', registration.name);
+  } else {
+    console.log('UAC: Domain already in database:', registration.name);
+  }
+
+  return {
+    port,
+    appUrl,
+    domain,
+    registration,
+    apiUrl,
+  };
+}
+
+module.exports = { boot };

package/lib/client.js

@@ -0,0 +1,85 @@
+const {
+  normalizeDomain,
+  isValidDomain,
+  resolveAppUrl,
+} = require('./normalizeDomain');
+const { DEFAULT_UAC_API_URL, normalizeApiBaseUrl } = require('./apiConfig');
+
+class UacError extends Error {
+  constructor(message, { status, code } = {}) {
+    super(message);
+    this.name = 'UacError';
+    this.status = status;
+    this.code = code;
+  }
+}
+
+function getApiUrl(options = {}) {
+  return normalizeApiBaseUrl(
+    options.apiUrl || process.env.UAC_API_URL || DEFAULT_UAC_API_URL
+  );
+}
+
+async function registerDomain(input, options = {}) {
+  const name = normalizeDomain(input);
+
+  if (!name) {
+    throw new UacError('Domain or URL is required', { code: 'INVALID_INPUT' });
+  }
+
+  if (!isValidDomain(name)) {
+    throw new UacError(`Invalid domain: ${name}`, { code: 'INVALID_DOMAIN' });
+  }
+
+  const apiUrl = getApiUrl(options);
+  const response = await fetch(`${apiUrl}/api/domains`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(options.headers || {}),
+    },
+    body: JSON.stringify({ name }),
+  });
+
+  const data = await response.json().catch(() => ({}));
+
+  if (response.status === 201) {
+    return {
+      created: true,
+      domain: data,
+      name: data.name,
+    };
+  }
+
+  if (response.status === 409) {
+    return {
+      created: false,
+      name,
+      message: 'Domain already registered',
+    };
+  }
+
+  throw new UacError(data.error || 'Failed to register domain', {
+    status: response.status,
+    code: 'REGISTER_FAILED',
+  });
+}
+
+async function init(input, options = {}) {
+  const config =
+    input && typeof input === 'object' && !Array.isArray(input)
+      ? input
+      : { ...(input ? { url: input } : {}), ...options };
+
+  const source = resolveAppUrl(config);
+
+  return registerDomain(source, config);
+}
+
+module.exports = {
+  UacError,
+  getApiUrl,
+  registerDomain,
+  init,
+  resolveAppUrl,
+};

package/lib/device.mjs

@@ -0,0 +1,67 @@
+const DEVICE_STORAGE_KEY = 'uac_device_id';
+
+function detectPlatform() {
+  const ua = navigator.userAgent || '';
+  const platform = navigator.userAgentData?.platform || navigator.platform || '';
+
+  if (/android/i.test(ua)) return 'mobile';
+  if (/iphone|ipad|ipod/i.test(ua)) return 'mobile';
+  if (/win/i.test(platform) || /windows/i.test(ua)) return 'windows';
+  if (/mac/i.test(platform) || /macintosh/i.test(ua)) return 'mac';
+  if (/linux/i.test(platform) || /linux/i.test(ua)) return 'linux';
+  if (/mobile/i.test(ua)) return 'mobile';
+
+  return 'unknown';
+}
+
+function getDeviceId() {
+  let deviceId = localStorage.getItem(DEVICE_STORAGE_KEY);
+
+  if (!deviceId) {
+    deviceId =
+      typeof crypto !== 'undefined' && crypto.randomUUID
+        ? crypto.randomUUID()
+        : `uac-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+
+    localStorage.setItem(DEVICE_STORAGE_KEY, deviceId);
+  }
+
+  return deviceId;
+}
+
+function getDeviceInfo() {
+  const timezone = Intl.DateTimeFormat().resolvedOptions();
+  const platform = detectPlatform();
+  const osLabel =
+    platform === 'windows'
+      ? 'Windows'
+      : platform === 'mac'
+        ? 'Mac'
+        : platform === 'linux'
+          ? 'Linux'
+          : platform === 'mobile'
+            ? 'Mobile'
+            : 'Unknown';
+
+  return {
+    deviceType: platform,
+    deviceName: navigator.userAgent.slice(0, 200),
+    deviceModel: navigator.platform || 'unknown',
+    deviceVersion: navigator.appVersion || 'unknown',
+    deviceManufacturer: navigator.vendor || 'unknown',
+    deviceOperatingSystem: osLabel,
+    deviceOperatingSystemVersion: navigator.userAgent.slice(0, 120),
+    deviceOperatingSystemArchitecture:
+      navigator.userAgentData?.platform || navigator.platform || 'unknown',
+    deviceOperatingSystemLanguage: navigator.language || 'unknown',
+    deviceOperatingSystemCountry: navigator.language?.split('-')[1] || 'unknown',
+    deviceOperatingSystemCity: 'unknown',
+    deviceOperatingSystemRegion: 'unknown',
+    deviceOperatingSystemPostalCode: 'unknown',
+    deviceOperatingSystemTimezone: timezone.timeZone || 'unknown',
+    deviceOperatingSystemTimezoneOffset: new Date().getTimezoneOffset(),
+    deviceOperatingSystemTimezoneName: timezone.timeZone || 'unknown',
+  };
+}
+
+export { getDeviceId, getDeviceInfo, detectPlatform };

package/lib/integrate.js

@@ -0,0 +1,120 @@
+const fs = require('fs');
+const path = require('path');
+
+const UAC_MARKER = 'uac-package';
+const UAC_AUTO_MARKER = '@uac-auto';
+const TRACK_IMPORT = `import '${UAC_MARKER}/track' // ${UAC_AUTO_MARKER}\n`;
+const ENTRY_FILES = ['src/main.js', 'src/main.ts', 'src/index.js', 'src/index.ts'];
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function hasUacDependency(pkg) {
+  return Boolean(
+    pkg.dependencies?.[UAC_MARKER] || pkg.devDependencies?.[UAC_MARKER]
+  );
+}
+
+function patchDevScript(script) {
+  if (!script || script.includes(UAC_MARKER)) {
+    return script;
+  }
+
+  return `node ./node_modules/${UAC_MARKER}/bin/cli.js dev ${script}`;
+}
+
+function patchNodeStartScript(script) {
+  if (!script || script.includes(`${UAC_MARKER}/register`)) {
+    return script;
+  }
+
+  if (/^node\s+/i.test(script)) {
+    return script.replace(/^node\s+/i, `node -r ${UAC_MARKER}/register `);
+  }
+
+  return `node -r ${UAC_MARKER}/register ${script}`;
+}
+
+function isViteProject(pkg) {
+  return Boolean(pkg.devDependencies?.vite || pkg.dependencies?.vite);
+}
+
+function injectClickTracker(projectRoot) {
+  for (const relPath of ENTRY_FILES) {
+    const filePath = path.join(projectRoot, relPath);
+
+    if (!fs.existsSync(filePath)) {
+      continue;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+
+    if (
+      content.includes(UAC_AUTO_MARKER) ||
+      content.includes(`${UAC_MARKER}/track`)
+    ) {
+      return false;
+    }
+
+    fs.writeFileSync(filePath, TRACK_IMPORT + content);
+    return true;
+  }
+
+  return false;
+}
+
+function integrate(projectRoot) {
+  const pkgPath = path.join(projectRoot, 'package.json');
+
+  if (!fs.existsSync(pkgPath)) {
+    return false;
+  }
+
+  const pkg = readJson(pkgPath);
+
+  if (pkg.name === UAC_MARKER || !hasUacDependency(pkg)) {
+    return false;
+  }
+
+  let changed = false;
+
+  if (isViteProject(pkg) && pkg.scripts) {
+    for (const name of ['dev', 'preview']) {
+      const next = patchDevScript(pkg.scripts[name]);
+      if (next && next !== pkg.scripts[name]) {
+        pkg.scripts[name] = next;
+        changed = true;
+      }
+    }
+  } else if (pkg.scripts?.start) {
+    const next = patchNodeStartScript(pkg.scripts.start);
+    if (next !== pkg.scripts.start) {
+      pkg.scripts.start = next;
+      changed = true;
+    }
+  }
+
+  if (injectClickTracker(projectRoot)) {
+    changed = true;
+  }
+
+  if (changed) {
+    writeJson(pkgPath, pkg);
+    console.log('[UAC] Auto-integrated — domains & clicks will track automatically');
+  }
+
+  return changed;
+}
+
+module.exports = {
+  integrate,
+  injectClickTracker,
+  patchDevScript,
+  patchNodeStartScript,
+  isViteProject,
+};

package/lib/normalizeDomain.js

@@ -0,0 +1,62 @@
+const DOMAIN_NAME_REGEX =
+  /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i;
+const LOCALHOST_REGEX = /^localhost(?::\d+)?$/;
+const IP_REGEX = /^(?:\d{1,3}\.){3}\d{1,3}(?::\d+)?$/;
+
+function normalizeDomain(input) {
+  let value = String(input || '').trim().toLowerCase();
+
+  if (!value) {
+    return '';
+  }
+
+  if (value.includes('://')) {
+    try {
+      value = new URL(value).host;
+    } catch {
+      value = value.replace(/^https?:\/\//, '').replace(/\/.*$/, '');
+    }
+  } else {
+    value = value.replace(/\/.*$/, '');
+  }
+
+  return value.replace(/^www\./, '');
+}
+
+function isValidDomain(name) {
+  return (
+    DOMAIN_NAME_REGEX.test(name) ||
+    LOCALHOST_REGEX.test(name) ||
+    IP_REGEX.test(name)
+  );
+}
+
+function resolveAppUrl(options = {}) {
+  if (options.url) {
+    return options.url;
+  }
+
+  if (options.domain) {
+    return options.domain;
+  }
+
+  if (options.name) {
+    return options.name;
+  }
+
+  const host = options.host || process.env.HOST || 'localhost';
+  const port = options.port || process.env.PORT;
+  const protocol = options.protocol || process.env.APP_PROTOCOL || 'http';
+
+  if (port) {
+    return `${protocol}://${host}:${port}`;
+  }
+
+  return `${protocol}://${host}`;
+}
+
+module.exports = {
+  normalizeDomain,
+  isValidDomain,
+  resolveAppUrl,
+};

package/lib/register.js

@@ -0,0 +1 @@
+require('./autoTrack').autoTrack();

package/lib/start.js

@@ -0,0 +1,34 @@
+const http = require('http');
+const { boot } = require('./boot');
+
+async function start(options = {}) {
+  const result = await boot(options);
+  const { port, appUrl, domain, registration } = result;
+
+  const server = http.createServer((_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(
+      JSON.stringify(
+        {
+          framework: 'plain-node',
+          message: 'App running with uac-package',
+          appUrl,
+          domain,
+          registration,
+        },
+        null,
+        2
+      )
+    );
+  });
+
+  return new Promise((resolve, reject) => {
+    server.listen(port, () => {
+      console.log(`UAC: App running at http://localhost:${port}`);
+      resolve({ server, ...result });
+    });
+    server.on('error', reject);
+  });
+}
+
+module.exports = { start };

package/lib/track.mjs

@@ -0,0 +1,147 @@
+import { getDeviceId, getDeviceInfo } from './device.mjs';
+import { DEFAULT_UAC_API_URL, normalizeApiBaseUrl } from './apiConfig.mjs';
+
+const pageStart = Date.now();
+
+function getApiUrl() {
+  if (typeof import.meta !== 'undefined' && import.meta.env?.VITE_UAC_API_URL) {
+    return normalizeApiBaseUrl(import.meta.env.VITE_UAC_API_URL);
+  }
+
+  return DEFAULT_UAC_API_URL;
+}
+
+function isTrackingEnabled() {
+  if (typeof import.meta !== 'undefined' && import.meta.env?.VITE_UAC_AUTO_TRACK === 'false') {
+    return false;
+  }
+
+  return true;
+}
+
+function getElementLabel(element) {
+  const tag = element.tagName?.toLowerCase() || 'unknown';
+  const id = element.id ? `#${element.id}` : '';
+  const className =
+    typeof element.className === 'string' && element.className
+      ? `.${element.className.trim().split(/\s+/)[0]}`
+      : '';
+
+  return `${tag}${id}${className}`;
+}
+
+function getClickName(element) {
+  return `click:${element.tagName?.toLowerCase() || 'element'}`;
+}
+
+function getClickDescription(element) {
+  const text = (element.innerText || element.textContent || '')
+    .trim()
+    .replace(/\s+/g, ' ')
+    .slice(0, 120);
+
+  return [text, getElementLabel(element), window.location.pathname]
+    .filter(Boolean)
+    .join(' | ');
+}
+
+async function sendHeartbeat() {
+  if (!isTrackingEnabled() || typeof document === 'undefined') {
+    return;
+  }
+
+  if (document.visibilityState === 'hidden') {
+    return;
+  }
+
+  const payload = {
+    domain: window.location.host,
+    deviceId: getDeviceId(),
+    device: getDeviceInfo(),
+    route: window.location.pathname,
+  };
+
+  try {
+    await fetch(`${getApiUrl()}/api/presence/heartbeat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+      keepalive: true,
+    });
+  } catch {
+    // Backend may be offline during local dev
+  }
+}
+
+async function trackClick(event) {
+  const target = event.target;
+  if (!(target instanceof Element)) {
+    return;
+  }
+
+  const clickedAt = new Date().toISOString();
+  const payload = {
+    domain: window.location.host,
+    deviceId: getDeviceId(),
+    device: getDeviceInfo(),
+    name: getClickName(target),
+    description: getClickDescription(target),
+    spentTime: Date.now() - pageStart,
+    clickedAt,
+  };
+
+  try {
+    await fetch(`${getApiUrl()}/api/activities`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+      keepalive: true,
+    });
+    sendHeartbeat();
+  } catch {
+    // Backend may be offline during local dev
+  }
+}
+
+function listenForRouteChanges() {
+  if (typeof window === 'undefined') return;
+
+  const notify = () => sendHeartbeat();
+
+  window.addEventListener('popstate', notify);
+
+  for (const method of ['pushState', 'replaceState']) {
+    const original = history[method].bind(history);
+    history[method] = (...args) => {
+      const result = original(...args);
+      notify();
+      return result;
+    };
+  }
+}
+
+function startHeartbeat() {
+  sendHeartbeat();
+  setInterval(sendHeartbeat, 30000);
+  listenForRouteChanges();
+
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') {
+      sendHeartbeat();
+    }
+  });
+}
+
+function startClickTracking() {
+  if (typeof window === 'undefined' || !isTrackingEnabled()) {
+    return;
+  }
+
+  getDeviceId();
+  document.addEventListener('click', trackClick, true);
+  startHeartbeat();
+}
+
+startClickTracking();
+
+export { startClickTracking, trackClick, sendHeartbeat };

package/lib/vite.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+import type { UacOptions } from '../index.d.ts';
+
+export function vitePlugin(options?: UacOptions): Plugin;
+export default function uacVite(options?: UacOptions): Plugin;

package/lib/vite.js

@@ -0,0 +1,28 @@
+const { autoTrack } = require('./autoTrack');
+
+function resolveServerHost(server) {
+  const host = server.config.server?.host;
+  if (typeof host === 'string' && host !== 'true') {
+    return host;
+  }
+  return 'localhost';
+}
+
+function vitePlugin(options = {}) {
+  return {
+    name: 'uac-package',
+    configureServer(server) {
+      server.httpServer?.once('listening', () => {
+        const address = server.httpServer?.address();
+        const port =
+          typeof address === 'object' && address?.port
+            ? address.port
+            : server.config.server?.port ?? 5173;
+
+        autoTrack({ ...options, port, host: resolveServerHost(server) });
+      });
+    },
+  };
+}
+
+module.exports = { vitePlugin, default: vitePlugin };

package/lib/vite.mjs

@@ -0,0 +1,10 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { vitePlugin } = require('./vite.js');
+
+export default function uacVite(options = {}) {
+  return vitePlugin(options);
+}
+
+export { vitePlugin };