linkfeed-pro 1.0.7

package/lib/license.ts

@@ -0,0 +1,470 @@
+import type { LicenseState, CachedLicenseState, FeatureFlags } from "@linkfeed/shared";
+import { OFFLINE_GRACE_HOURS } from "@linkfeed/shared";
+import { deviceIdStorage, userEmailStorage, cachedLicenseStorage, deviceTokenStorage, licenseRefreshStorage } from "./storage";
+import { API_BASE_URL } from "./constants";
+import { getDeviceMetadata } from "./device-meta";
+import { t } from "./i18n";
+import { browser } from "#imports";
+import { z } from "zod";
+
+const FeatureFlagsSchema = z.object({
+  wideFeed: z.boolean(),
+  fontSize: z.boolean(),
+  autoExpandPosts: z.boolean(),
+});
+
+const LicenseStateSchema = z.object({
+  status: z.enum(["active", "trial-active", "trial-expired", "revoked"]),
+  features: FeatureFlagsSchema,
+  expiresAt: z.string().optional(),
+});
+
+const FREE_FEATURES: FeatureFlags = {
+  wideFeed: false,
+  fontSize: false,
+  autoExpandPosts: false,
+};
+
+const IS_SERVICE_WORKER = typeof window === "undefined";
+const ACTIVE_CACHE_TTL_HOURS = 24;
+const TRIAL_CACHE_TTL_HOURS = 1;
+const REVOKED_CACHE_TTL_HOURS = 6;
+const ERROR_BACKOFF_MS = [5 * 60 * 1000, 30 * 60 * 1000, 6 * 60 * 60 * 1000];
+const MAX_FAILURE_COUNT = ERROR_BACKOFF_MS.length;
+
+type ApiResponse<T> = {
+  ok: boolean;
+  status: number;
+  data: T | null;
+};
+
+async function apiFetchJson<T>(path: string, init?: RequestInit): Promise<ApiResponse<T>> {
+  const url = `${API_BASE_URL}${path.startsWith("/") ? "" : "/"}${path}`;
+  const headers = new Headers(init?.headers ?? undefined);
+  headers.set("x-linkfeed-extension-version", browser.runtime.getManifest().version);
+
+  if (IS_SERVICE_WORKER) {
+    const response = await fetch(url, {
+      ...init,
+      headers,
+    });
+    const data = (await response.json().catch(() => null)) as T | null;
+    return { ok: response.ok, status: response.status, data };
+  }
+
+  const serializedHeaders: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    serializedHeaders[key] = value;
+  });
+
+  const payload = {
+    type: "linkfeed_api_fetch",
+    url,
+    method: init?.method || "GET",
+    headers: serializedHeaders,
+    body: typeof init?.body === "string" ? init.body : undefined,
+  };
+
+  const result = await browser.runtime.sendMessage(payload) as ApiResponse<T> | undefined;
+  if (!result) {
+    return { ok: false, status: 0, data: null };
+  }
+  return result;
+}
+
+type LicenseFetchOptions = { force?: boolean };
+
+async function requestLicenseStateFromBackground(options?: LicenseFetchOptions): Promise<LicenseState | null> {
+  try {
+    const result = await browser.runtime.sendMessage({
+      type: "linkfeed_license_refresh",
+      force: Boolean(options?.force),
+    }) as LicenseState | null;
+    return result ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Generate or retrieve a persistent device ID
+ */
+export async function getDeviceId(): Promise<string> {
+  return (await deviceIdStorage.getValue()) as string;
+}
+
+/**
+ * Get stored user email
+ */
+export async function getUserEmail(): Promise<string | null> {
+  return await userEmailStorage.getValue();
+}
+
+/**
+ * Store user email
+ */
+export async function setUserEmail(email: string): Promise<void> {
+  await userEmailStorage.setValue(email);
+}
+
+/**
+ * Get cached license state
+ */
+export async function getCachedLicense(): Promise<CachedLicenseState | null> {
+  return (await cachedLicenseStorage.getValue()) as CachedLicenseState | null;
+}
+
+/**
+ * Cache license state
+ */
+async function cacheLicenseState(state: LicenseState): Promise<void> {
+  const cached: CachedLicenseState = {
+    ...state,
+    cachedAt: Date.now(),
+  };
+  await cachedLicenseStorage.setValue(cached);
+}
+
+/**
+ * Check if cached license is still valid (within offline grace period)
+ */
+function isCacheValid(cached: CachedLicenseState): boolean {
+  const graceMs = OFFLINE_GRACE_HOURS * 60 * 60 * 1000;
+  return Date.now() - cached.cachedAt < graceMs;
+}
+
+function getCacheTtlMs(cached: CachedLicenseState): number {
+  if (cached.status === "trial-active") return TRIAL_CACHE_TTL_HOURS * 60 * 60 * 1000;
+  if (cached.status === "active") return ACTIVE_CACHE_TTL_HOURS * 60 * 60 * 1000;
+  return REVOKED_CACHE_TTL_HOURS * 60 * 60 * 1000;
+}
+
+function isCacheFresh(cached: CachedLicenseState): boolean {
+  return Date.now() - cached.cachedAt < getCacheTtlMs(cached);
+}
+
+async function getRefreshState() {
+  return await licenseRefreshStorage.getValue();
+}
+
+async function setRefreshState(state: { failureCount: number; retryAfter: number }) {
+  await licenseRefreshStorage.setValue(state);
+}
+
+function getBackoffDelayMs(failureCount: number): number {
+  const index = Math.min(Math.max(failureCount - 1, 0), ERROR_BACKOFF_MS.length - 1);
+  return ERROR_BACKOFF_MS[index];
+}
+
+/**
+ * Fetch license status from API
+ */
+export async function fetchLicenseStatus(options?: LicenseFetchOptions): Promise<LicenseState> {
+  const deviceToken = await deviceTokenStorage.getValue();
+  const cached = await getCachedLicense();
+  const refreshState = await getRefreshState();
+  const force = Boolean(options?.force);
+
+  if (!deviceToken) {
+    // Not logged in - return free features
+    return {
+      status: "revoked",
+      features: FREE_FEATURES,
+    };
+  }
+
+  // If cache is still fresh, return it without hitting the network
+  if (!force && cached && isCacheFresh(cached)) {
+    return cached;
+  }
+
+  // Respect global backoff after previous failures
+  if (!force && refreshState.retryAfter && Date.now() < refreshState.retryAfter) {
+    if (cached && isCacheValid(cached)) return cached;
+    return {
+      status: "revoked",
+      features: FREE_FEATURES,
+    };
+  }
+
+  // If offline, immediately use cache if possible
+  if (typeof navigator !== 'undefined' && !navigator.onLine) {
+    if (cached && isCacheValid(cached)) {
+      console.log("Offline: Using cached license");
+      return cached;
+    }
+  }
+
+  try {
+    const url = new URL(`${API_BASE_URL}/api/license/status`);
+    url.searchParams.set("deviceToken", deviceToken);
+
+    const deviceMeta = await getDeviceMetadata();
+    const response = await apiFetchJson<LicenseState>(`/api/license/status?deviceToken=${encodeURIComponent(deviceToken)}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...(deviceMeta ? { "X-Linkfeed-Device-Meta": JSON.stringify(deviceMeta) } : {}),
+      },
+    });
+
+    if (!response.ok || !response.data) {
+      const failureCount = Math.min(refreshState.failureCount + 1, MAX_FAILURE_COUNT);
+      const retryAfter = Date.now() + getBackoffDelayMs(failureCount);
+      await setRefreshState({ failureCount, retryAfter });
+      if (cached && isCacheValid(cached)) {
+        return cached;
+      }
+      return {
+        status: "revoked",
+        features: FREE_FEATURES,
+      };
+    }
+
+    const data = LicenseStateSchema.parse(response.data);
+    await cacheLicenseState(data);
+    await setRefreshState({ failureCount: 0, retryAfter: 0 });
+    return data;
+  } catch (error) {
+    const failureCount = Math.min(refreshState.failureCount + 1, MAX_FAILURE_COUNT);
+    const retryAfter = Date.now() + getBackoffDelayMs(failureCount);
+    await setRefreshState({ failureCount, retryAfter });
+
+    // Try to use cached license
+    if (cached && isCacheValid(cached)) {
+      return cached;
+    }
+
+    // Fallback to free features
+    return {
+      status: "revoked",
+      features: FREE_FEATURES,
+    };
+  }
+}
+
+/**
+ * Get current license state (with offline grace)
+ */
+export async function getLicenseState(options?: LicenseFetchOptions): Promise<LicenseState> {
+  if (IS_SERVICE_WORKER) {
+    return fetchLicenseStatus(options);
+  }
+
+  const fromBackground = await requestLicenseStateFromBackground(options);
+  if (fromBackground) return fromBackground;
+
+  const cached = await getCachedLicense();
+  if (cached) return cached;
+
+  return {
+    status: "revoked",
+    features: FREE_FEATURES,
+  };
+}
+
+/**
+ * Check if a specific feature is enabled
+ */
+export async function isFeatureEnabled(feature: keyof FeatureFlags): Promise<boolean> {
+  const state = await getLicenseState();
+  return state.features[feature];
+}
+
+/**
+ * Start trial via API
+ */
+export async function startTrial(email: string): Promise<{ success: boolean; message: string; expiresAt?: string }> {
+  const result = await requestLicenseLink(email);
+  return {
+    success: result.success,
+    message: result.message,
+  };
+}
+
+/**
+ * Clear stored license data (for logout)
+ */
+export async function clearLicenseData(): Promise<void> {
+  await Promise.all([
+    userEmailStorage.removeValue(),
+    cachedLicenseStorage.removeValue(),
+    deviceTokenStorage.removeValue(),
+    licenseRefreshStorage.removeValue(),
+  ]);
+}
+
+export async function setDeviceToken(token: string): Promise<void> {
+  await deviceTokenStorage.setValue(token);
+}
+
+export async function getDeviceToken(): Promise<string | null> {
+  return await deviceTokenStorage.getValue();
+}
+
+export async function requestLicenseLink(email: string): Promise<{ success: boolean; message: string; activationToken?: string }> {
+  const deviceId = await getDeviceId();
+  const deviceMeta = await getDeviceMetadata();
+
+  if (typeof navigator !== 'undefined' && !navigator.onLine) {
+    return {
+      success: false,
+      message: t('errorNoInternet'),
+    };
+  }
+
+  try {
+    const response = await apiFetchJson<{ success: boolean; message?: string; activationToken?: string; error?: string }>(`/api/license/link/request`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        email,
+        deviceId,
+        ...(deviceMeta ? { deviceMeta } : {}),
+      }),
+    });
+
+    const rawData = (response.data ?? {}) as {
+      success?: boolean;
+      message?: string;
+      activationToken?: string;
+      error?: string;
+    };
+    if (!response.ok) {
+      return {
+        success: false,
+        message: rawData.error || "Failed to send link",
+      };
+    }
+
+    return {
+      success: true,
+      message: rawData.message || "Check your email to confirm",
+      activationToken: rawData.activationToken,
+    };
+  } catch (error) {
+    console.error("Failed to request license link:", error);
+    return {
+      success: false,
+      message: error instanceof z.ZodError ? t('errorServerInvalid') : t('errorConnectFailed'),
+    };
+  }
+}
+
+export async function activateLicenseLink(activationToken: string): Promise<{ success: boolean; message: string; status?: string; license?: LicenseState; deviceToken?: string }> {
+  const deviceId = await getDeviceId();
+
+  if (typeof navigator !== 'undefined' && !navigator.onLine) {
+    return {
+      success: false,
+      message: t('errorNoInternet'),
+    };
+  }
+
+  try {
+    const deviceMeta = await getDeviceMetadata();
+    const payload = deviceMeta
+      ? { activationToken, deviceId, deviceMeta }
+      : { activationToken, deviceId };
+    const response = await apiFetchJson<{ success?: boolean; message?: string; status?: string; license?: LicenseState; deviceToken?: string; email?: string; error?: string }>(`/api/license/link/activate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+
+    const rawData = (response.data ?? {}) as {
+      success?: boolean;
+      message?: string;
+      status?: string;
+      license?: LicenseState;
+      deviceToken?: string;
+      email?: string;
+      error?: string;
+    };
+    if (!response.ok) {
+      return {
+        success: false,
+        message: rawData.error || "Failed to activate license",
+        status: rawData.status,
+      };
+    }
+
+    if (rawData.deviceToken) {
+      await setDeviceToken(rawData.deviceToken);
+    }
+    if (rawData.email) {
+      await setUserEmail(rawData.email);
+    }
+    if (rawData.license) {
+      await cacheLicenseState(rawData.license);
+    }
+
+    return {
+      success: true,
+      message: "License linked",
+      license: rawData.license,
+      deviceToken: rawData.deviceToken,
+    };
+  } catch (error) {
+    console.error("Failed to activate license:", error);
+    return {
+      success: false,
+      message: error instanceof z.ZodError ? t('errorServerInvalid') : t('errorConnectFailed'),
+    };
+  }
+}
+
+export async function createStripeCheckoutForEmail(
+  email: string,
+  options?: {
+    planType?: 'subscription' | 'lifetime';
+    billingCycle?: 'monthly' | 'yearly';
+    currency?: 'USD' | 'EUR';
+  }
+): Promise<{ success: boolean; url?: string; message?: string }> {
+  if (typeof navigator !== "undefined" && !navigator.onLine) {
+    return {
+      success: false,
+      message: t("errorNoInternet"),
+    };
+  }
+
+  try {
+    const response = await apiFetchJson<{ url?: string; error?: string }>(`/api/stripe/checkout-email`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        email,
+        planType: options?.planType ?? 'subscription',
+        billingCycle: options?.billingCycle ?? 'monthly',
+        currency: options?.currency ?? 'USD',
+      }),
+    });
+
+    const rawData = (response.data ?? {}) as { url?: string; error?: string };
+    if (!response.ok) {
+      return {
+        success: false,
+        message: rawData.error || t("errorConnectFailed"),
+      };
+    }
+
+    if (!rawData.url) {
+      return {
+        success: false,
+        message: t("errorServerInvalid"),
+      };
+    }
+
+    return {
+      success: true,
+      url: rawData.url,
+    };
+  } catch (error) {
+    console.error("Failed to create Stripe checkout:", error);
+    return {
+      success: false,
+      message: t("errorConnectFailed"),
+    };
+  }
+}

package/lib/selectors.ts

@@ -0,0 +1,24 @@
+/**
+ * Centralized LinkedIn specific selectors for resilience
+ * If LinkedIn updates their UI, we only need to update this file.
+ */
+export const LNK_SELECTORS = {
+    // Layout
+    SCROLL_CONTENT: '.scaffold-finite-scroll__content',
+    MAIN_GRID: '.scaffold-layout__content',
+    FEED_ITEM: '.scaffold-finite-scroll__content-item, .feed-shared-update-v2, .feed-shared-update-v1',
+    FEED_SKIP_LINK: 'h2.feed-skip-link__container',
+    SIDEBAR_RIGHT: '.scaffold-layout__aside',
+    SIDEBAR_LEFT: '.scaffold-layout__sidebar',
+    NAV_BAR: '.global-nav, header[role="banner"]',
+
+    // Components
+    SEE_MORE_BTN: '.feed-shared-inline-show-more-text__see-more-less-toggle',
+    POST_CONTAINER: '.feed-shared-update-v2, .feed-shared-update-v1',
+    ACTION_BUTTON: 'button, a[role="button"], span[role="button"]',
+    SHARE_BOX: '.share-box-feed-entry__closed-share-box, .share-box-feed-entry',
+    MESSENGER: '.msg-overlay-container, aside.msg-overlay-list-bubble, .msg-overlay-bubble-header',
+
+    // Text
+    POST_TEXT: '.feed-shared-update-v2__description, .feed-shared-text, .update-components-text'
+};

package/lib/storage.ts

@@ -0,0 +1,95 @@
+import { storage } from '#imports';
+import type { CachedLicenseState } from '@linkfeed/shared';
+
+// ============================
+// SETTINGS
+// ============================
+export interface Settings {
+    globalEnabled: boolean;
+    hideSidebars: boolean;
+    hidePromoted: boolean;
+    feedWidth: number;
+    feedSpacing: number;
+    autoExpandPosts: boolean;
+    hideRemovedFeedCards: boolean;
+    hideStartPost: boolean;
+    hideMessenger: boolean;
+    hideNavBar: boolean;
+    fontSize: number;
+}
+
+export type UiLocalePreference =
+    | "auto"
+    | "en"
+    | "fr"
+    | "de"
+    | "es"
+    | "pt-pt"
+    | "pt-br"
+    | "it"
+    | "nl"
+    | "pl"
+    | "tr"
+    | "id"
+    | "hi";
+
+export const DEFAULT_SETTINGS: Settings = {
+    globalEnabled: true,
+    hideSidebars: true,
+    hidePromoted: false,
+    feedWidth: 1500,
+    feedSpacing: 40,
+    autoExpandPosts: true,
+    hideRemovedFeedCards: true,
+    hideStartPost: false,
+    hideMessenger: false,
+    hideNavBar: false,
+    fontSize: 20,
+};
+
+export const settingsStorage = storage.defineItem<Settings>('local:settings', {
+    fallback: DEFAULT_SETTINGS,
+});
+
+// ============================
+// IDENTITY & LICENSE
+// ============================
+
+export const deviceIdStorage = storage.defineItem<string>('local:deviceId', {
+    init: () => crypto.randomUUID(),
+});
+
+export const userEmailStorage = storage.defineItem<string | null>('local:userEmail', {
+    fallback: null,
+});
+
+export const cachedLicenseStorage = storage.defineItem<CachedLicenseState | null>('local:licenseState', {
+    fallback: null,
+});
+
+export const deviceTokenStorage = storage.defineItem<string | null>('local:deviceToken', {
+    fallback: null,
+});
+
+export interface LicenseRefreshState {
+    failureCount: number;
+    retryAfter: number;
+}
+
+export const licenseRefreshStorage = storage.defineItem<LicenseRefreshState>('local:licenseRefresh', {
+    fallback: { failureCount: 0, retryAfter: 0 },
+});
+
+// Telemetry state (internal)
+export const telemetryIdentitySentStorage = storage.defineItem<{ email: string | null; status: string | null }>('local:telemetry:identitySent', {
+    fallback: { email: null, status: null }
+});
+
+// Pending Trial Flow state
+export const pendingTrialStorage = storage.defineItem<{ email: string; activationToken: string; timestamp: number } | null>('local:pendingTrial', {
+    fallback: null,
+});
+
+export const uiLocaleStorage = storage.defineItem<UiLocalePreference>('local:uiLocalePreference', {
+    fallback: "auto",
+});

package/lib/telemetry.ts

@@ -0,0 +1,94 @@
+import { init } from '@extension-report/js';
+import { userEmailStorage, cachedLicenseStorage, settingsStorage, telemetryIdentitySentStorage } from './storage';
+
+const PROJECT_PUBLIC_KEY = 'pk_er_80fa598197dccecd7219fa262c47e6219005';
+
+export const sdk = init({
+    projectPublicKey: PROJECT_PUBLIC_KEY,
+    app: {
+        type: 'extension'
+    }
+});
+
+interface UserIdentity {
+    email: string | null;
+    status: string | null; // free / trial / pro
+}
+
+export async function syncIdentity(force = false) {
+    try {
+        const email = await userEmailStorage.getValue();
+        const license = await cachedLicenseStorage.getValue();
+
+        let status = 'free';
+        if (license?.status === 'active') status = 'pro';
+        else if (license?.status === 'trial-active') status = 'trial';
+        else if (license?.status === 'trial-expired') status = 'expired';
+
+        const currentIdentity: UserIdentity = {
+            email: email,
+            status: status
+        };
+
+        const lastSent = await telemetryIdentitySentStorage.getValue();
+
+        // Check if identity changed
+        const changed =
+            currentIdentity.email !== lastSent.email ||
+            currentIdentity.status !== lastSent.status;
+
+        if (!currentIdentity.email) {
+            return;
+        }
+
+        if (changed || force) {
+            await sdk.track('user_identify', {
+                user_id: currentIdentity.email,
+                email: currentIdentity.email,
+                status: currentIdentity.status,
+                traits: {
+                    license_status: currentIdentity.status
+                }
+            });
+
+            await telemetryIdentitySentStorage.setValue(currentIdentity);
+        }
+    } catch (err) {
+        console.warn('[Telemetry] Failed to sync identity', err);
+    }
+}
+
+export async function getDailyPayload() {
+    try {
+        const settings = await settingsStorage.getValue();
+        const email = await userEmailStorage.getValue();
+        const license = await cachedLicenseStorage.getValue();
+
+        let status = 'free';
+        if (license?.status === 'active') status = 'pro';
+        else if (license?.status === 'trial-active') status = 'trial';
+        else if (license?.status === 'trial-expired') status = 'expired';
+
+        const hideSidebars = settings.hideSidebars ?? (settings as { removeSidebars?: boolean }).removeSidebars;
+
+        return {
+            settings: {
+                hideSidebars: Boolean(hideSidebars),
+                hidePromoted: Boolean(settings.hidePromoted),
+                hideStartPost: Boolean(settings.hideStartPost),
+                hideMessenger: Boolean(settings.hideMessenger),
+                autoExpandPosts: Boolean(settings.autoExpandPosts),
+                textSize: Number(settings.fontSize || 16),
+                feedWidth: Number(settings.feedWidth || 800),
+                feedSpacing: Number(settings.feedSpacing || 24)
+            },
+            user: {
+                email: email,
+                status: status
+            }
+        };
+    } catch (err) {
+        console.warn('[Telemetry] Failed to get daily payload', err);
+        return {};
+    }
+}