offcourse 1.0.0 → 1.1.0

package/src/shared/auth.ts

@@ -1,251 +0,0 @@
-import type { Browser, BrowserContext, Page } from "playwright";
-import { chromium } from "playwright";
-import { getSessionPath, SESSIONS_DIR } from "../config/paths.js";
-import { ensureDir, outputJson, pathExists, readJson, removeFile } from "./fs.js";
-
-export interface AuthSession {
-  context: BrowserContext;
-  page: Page;
-}
-
-export interface AuthConfig {
-  /** Domain to store session under */
-  domain: string;
-  /** URL to navigate to for login */
-  loginUrl: string;
-  /** Function to check if current URL is a login page */
-  isLoginPage: (url: string) => boolean;
-  /** Optional: Function to verify session is valid after navigation */
-  verifySession?: (page: Page) => Promise<boolean>;
-  /** Login timeout in ms (default: 5 minutes) */
-  loginTimeout?: number;
-}
-
-/**
- * Default login page detection patterns.
- */
-const DEFAULT_LOGIN_PATTERNS = [
-  /\/login/,
-  /\/signin/,
-  /\/auth/,
-  /accounts\.google\.com/,
-  /firebaseapp\.com/,
-  /sso\./,
-];
-
-/**
- * Creates a login page checker from patterns.
- */
-export function createLoginChecker(
-  patterns: RegExp[] = DEFAULT_LOGIN_PATTERNS
-): (url: string) => boolean {
-  return (url: string) => patterns.some((p) => p.test(url));
-}
-
-/**
- * Skool-specific login page checker.
- */
-export const isSkoolLoginPage = createLoginChecker([/\/login/, /accounts\.google\.com/]);
-
-/**
- * HighLevel-specific login page checker.
- */
-export const isHighLevelLoginPage = createLoginChecker([
-  /sso\.clientclub\.net/,
-  /\/login/,
-  /\/signin/,
-  /\/auth/,
-  /accounts\.google\.com/,
-  /firebaseapp\.com/,
-]);
-
-// ============================================
-// Browser automation - not unit testable
-// ============================================
-/* v8 ignore start */
-
-/**
- * Checks if a valid session exists for the given domain.
- */
-export async function hasValidSession(domain: string): Promise<boolean> {
-  const sessionPath = getSessionPath(domain);
-  return pathExists(sessionPath);
-}
-
-/**
- * Loads an existing session from disk.
- */
-async function loadSession(browser: Browser, domain: string): Promise<BrowserContext> {
-  const sessionPath = getSessionPath(domain);
-  // Playwright's storageState type is complex, we load it as-is from JSON
-  const storageState = await readJson(sessionPath);
-  if (!storageState) {
-    throw new Error("Session file not found or invalid");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-  return browser.newContext({ storageState: storageState as any });
-}
-
-/**
- * Saves the current session to disk.
- */
-async function saveSession(context: BrowserContext, domain: string): Promise<void> {
-  const sessionPath = getSessionPath(domain);
-  const storageState = await context.storageState();
-  await outputJson(sessionPath, storageState);
-}
-
-/**
- * Performs interactive login by opening a browser window.
- * The user logs in manually, and we capture the session.
- */
-export async function performInteractiveLogin(config: AuthConfig): Promise<AuthSession> {
-  await ensureDir(SESSIONS_DIR);
-
-  const browser = await chromium.launch({
-    headless: false, // Must be visible for user interaction
-  });
-
-  const context = await browser.newContext({
-    viewport: { width: 1280, height: 800 },
-  });
-
-  const page = await context.newPage();
-  await page.goto(config.loginUrl);
-
-  console.log("\n🔐 Browser opened. Please log in manually.");
-  console.log("   The window will close automatically after successful login.\n");
-
-  const timeout = config.loginTimeout ?? 300000; // 5 minutes default
-  const startTime = Date.now();
-  let loggedIn = false;
-
-  while (!loggedIn && Date.now() - startTime < timeout) {
-    await page.waitForTimeout(1000);
-
-    const currentUrl = page.url();
-
-    // Check if we're no longer on a login page
-    if (!config.isLoginPage(currentUrl)) {
-      // Optionally verify with custom function
-      if (config.verifySession) {
-        loggedIn = await config.verifySession(page);
-      } else {
-        loggedIn = true;
-      }
-    }
-  }
-
-  if (!loggedIn) {
-    await browser.close();
-    throw new Error(`Login timed out after ${timeout / 1000} seconds`);
-  }
-
-  // Give the page a moment to fully load after login
-  await page.waitForLoadState("networkidle").catch(() => {});
-  await page.waitForTimeout(1000);
-
-  // Save the session
-  await saveSession(context, config.domain);
-
-  console.log("✅ Login successful! Session saved.\n");
-
-  return { context, page };
-}
-
-/**
- * Gets an authenticated session, either from cache or via interactive login.
- */
-export async function getAuthenticatedSession(
-  config: AuthConfig,
-  options: { forceLogin?: boolean; headless?: boolean } = {}
-): Promise<{ browser: Browser; session: AuthSession }> {
-  const useHeadless = options.headless !== false;
-
-  const browser = await chromium.launch({
-    headless: useHeadless,
-  });
-
-  // Try to use existing session
-  if (!options.forceLogin && (await hasValidSession(config.domain))) {
-    try {
-      const context = await loadSession(browser, config.domain);
-      const page = await context.newPage();
-
-      // Navigate to verify session
-      await page.goto(config.loginUrl);
-      await page.waitForLoadState("domcontentloaded");
-      await page.waitForTimeout(2000);
-
-      const currentUrl = page.url();
-
-      // Check if we got redirected to login
-      if (config.isLoginPage(currentUrl)) {
-        console.log("⚠️  Session expired, need to re-login...");
-        await context.close();
-        await browser.close();
-      } else {
-        // Optionally verify session
-        if (config.verifySession) {
-          const isValid = await config.verifySession(page);
-          if (!isValid) {
-            console.log("⚠️  Session invalid, need to re-login...");
-            await context.close();
-            await browser.close();
-          } else {
-            console.log("✅ Using cached session");
-            return { browser, session: { context, page } };
-          }
-        } else {
-          console.log("✅ Using cached session");
-          return { browser, session: { context, page } };
-        }
-      }
-    } catch (error) {
-      console.log("⚠️  Failed to load session, need to re-login...", error);
-      await browser.close();
-    }
-  } else {
-    await browser.close();
-  }
-
-  // Need fresh login - always visible for interactive login
-  const session = await performInteractiveLogin(config);
-
-  // Get the browser from the session context
-  const sessionBrowser = session.context.browser();
-  if (!sessionBrowser) {
-    throw new Error("Failed to get browser from session");
-  }
-
-  // After login, reopen with headless browser if needed
-  if (useHeadless) {
-    const newBrowser = await chromium.launch({ headless: true });
-    const context = await loadSession(newBrowser, config.domain);
-    const page = await context.newPage();
-
-    // Close the interactive session
-    await sessionBrowser.close();
-
-    return { browser: newBrowser, session: { context, page } };
-  }
-
-  return { browser: sessionBrowser, session };
-}
-
-/**
- * Clears the session for a domain.
- */
-export async function clearSession(domain: string): Promise<boolean> {
-  const sessionPath = getSessionPath(domain);
-  return removeFile(sessionPath);
-}
-
-/**
- * Checks if the page has a valid Firebase auth token.
- * Used by HighLevel/GoHighLevel portals.
- */
-// Re-export Firebase auth utilities (used by multiple platforms)
-export { hasValidFirebaseToken } from "./firebase.js";
-
-/* v8 ignore stop */

package/src/shared/firebase.ts

@@ -1,151 +0,0 @@
-/**
- * Firebase Authentication utilities.
- *
- * Firebase Auth is used by many platforms (HighLevel, etc.) for user authentication.
- * This module provides shared types, schemas, and utilities for Firebase Auth tokens
- * stored in localStorage.
- */
-
-import { z } from "zod";
-import type { Page } from "playwright";
-
-// ============================================================================
-// Schemas & Types
-// ============================================================================
-
-/**
- * Zod schema for validated Firebase auth token from localStorage.
- * Use this after parsing to ensure the token has all required fields.
- */
-export const FirebaseAuthTokenSchema = z.object({
-  stsTokenManager: z.object({
-    accessToken: z.string(),
-    expirationTime: z.number().optional(),
-    refreshToken: z.string().optional(),
-  }),
-});
-
-export type FirebaseAuthToken = z.infer<typeof FirebaseAuthTokenSchema>;
-
-/**
- * Raw Firebase auth data structure from localStorage (before validation).
- * Use this type when parsing JSON from localStorage.
- */
-export interface FirebaseAuthRaw {
-  stsTokenManager?: {
-    accessToken?: string;
-    expirationTime?: number;
-    refreshToken?: string;
-  };
-}
-
-// ============================================================================
-// localStorage Key Detection
-// ============================================================================
-
-/**
- * The localStorage key pattern for Firebase auth tokens.
- * Firebase stores auth tokens with keys like "firebase:authUser:API_KEY:[DEFAULT]"
- */
-export const FIREBASE_AUTH_KEY_PATTERN = "firebase:authUser";
-
-/**
- * Finds the Firebase auth token key in localStorage.
- * Returns null if no Firebase auth token is found.
- */
-export function findFirebaseAuthKey(storage: Storage): string | null {
-  return Object.keys(storage).find((k) => k.includes(FIREBASE_AUTH_KEY_PATTERN)) ?? null;
-}
-
-// ============================================================================
-// Token Utilities
-// ============================================================================
-
-/**
- * Checks if a Firebase auth token is expired.
- */
-export function isTokenExpired(token: FirebaseAuthRaw): boolean {
-  const expirationTime = token.stsTokenManager?.expirationTime;
-  if (!expirationTime) {
-    // No expiration time means we can't determine if expired
-    // Assume valid if we have an access token
-    return !token.stsTokenManager?.accessToken;
-  }
-  return Date.now() >= expirationTime;
-}
-
-/**
- * Extracts the access token from Firebase auth data.
- */
-export function getAccessToken(token: FirebaseAuthRaw): string | undefined {
-  return token.stsTokenManager?.accessToken;
-}
-
-// ============================================================================
-// Page Utilities (Playwright)
-// ============================================================================
-
-/* v8 ignore start */
-
-/**
- * Checks if the page has a valid (non-expired) Firebase auth token in localStorage.
- */
-export async function hasValidFirebaseToken(page: Page): Promise<boolean> {
-  try {
-    return await page.evaluate(
-      ({ keyPattern }) => {
-        const tokenKey = Object.keys(localStorage).find((k) => k.includes(keyPattern));
-        if (!tokenKey) return false;
-
-        interface FirebaseAuthData {
-          stsTokenManager?: {
-            accessToken?: string;
-            expirationTime?: number;
-          };
-        }
-
-        const tokenData = JSON.parse(localStorage.getItem(tokenKey) ?? "{}") as FirebaseAuthData;
-        const expirationTime = tokenData?.stsTokenManager?.expirationTime;
-
-        if (expirationTime) {
-          return Date.now() < expirationTime;
-        }
-
-        return !!tokenData?.stsTokenManager?.accessToken;
-      },
-      { keyPattern: FIREBASE_AUTH_KEY_PATTERN }
-    );
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Extracts the Firebase auth token from the page's localStorage.
- * Returns the raw token data or null if not found.
- */
-export async function extractFirebaseAuthFromPage(page: Page): Promise<FirebaseAuthRaw | null> {
-  return page.evaluate(
-    ({ keyPattern }): FirebaseAuthRaw | null => {
-      const tokenKey = Object.keys(localStorage).find((k) => k.includes(keyPattern));
-      if (!tokenKey) return null;
-
-      interface FirebaseAuthData {
-        stsTokenManager?: {
-          accessToken?: string;
-          expirationTime?: number;
-          refreshToken?: string;
-        };
-      }
-
-      try {
-        return JSON.parse(localStorage.getItem(tokenKey) ?? "{}") as FirebaseAuthData;
-      } catch {
-        return null;
-      }
-    },
-    { keyPattern: FIREBASE_AUTH_KEY_PATTERN }
-  );
-}
-
-/* v8 ignore stop */

package/src/shared/fs.ts

@@ -1,80 +0,0 @@
-/**
- * Thin wrappers around fs/promises for common operations.
- * Excluded from coverage - testing would just test Node.js itself.
- */
-import { mkdir, readFile, writeFile, unlink, access, stat } from "node:fs/promises";
-import { dirname } from "node:path";
-
-/**
- * Check if a file or directory exists.
- */
-export async function pathExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Ensure a directory exists, creating it recursively if needed.
- */
-export async function ensureDir(dir: string): Promise<void> {
-  await mkdir(dir, { recursive: true });
-}
-
-/**
- * Write a file, creating parent directories if needed.
- */
-export async function outputFile(path: string, data: string): Promise<void> {
-  await ensureDir(dirname(path));
-  await writeFile(path, data, "utf-8");
-}
-
-/**
- * Write JSON to a file, creating parent directories if needed.
- */
-export async function outputJson(path: string, data: unknown): Promise<void> {
-  await outputFile(path, JSON.stringify(data, null, 2));
-}
-
-/**
- * Read and parse a JSON file.
- * Returns null if file doesn't exist or can't be parsed.
- */
-export async function readJson<T = unknown>(path: string): Promise<T | null> {
-  try {
-    const content = await readFile(path, "utf-8");
-    return JSON.parse(content) as T;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Remove a file if it exists.
- */
-export async function removeFile(path: string): Promise<boolean> {
-  try {
-    await unlink(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get file size in bytes, or null if file doesn't exist.
- */
-export async function getFileSize(path: string): Promise<number | null> {
-  try {
-    const stats = await stat(path);
-    return stats.size;
-  } catch {
-    return null;
-  }
-}
-
-// Re-export commonly used fs/promises functions
-export { readFile, writeFile, mkdir, unlink, stat } from "node:fs/promises";

package/src/shared/http.ts

@@ -1,34 +0,0 @@
-import ky from "ky";
-
-/**
- * Default User-Agent for HTTP requests.
- * Mimics a standard Chrome browser on macOS.
- */
-export const USER_AGENT =
-  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
-
-/**
- * Pre-configured HTTP client with sensible defaults.
- * Uses ky for automatic retries, better error handling, and cleaner API.
- */
-export const http = ky.create({
-  headers: {
-    "User-Agent": USER_AGENT,
-    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
-    "Accept-Language": "en-US,en;q=0.5",
-  },
-  timeout: 30000,
-  retry: {
-    limit: 2,
-    statusCodes: [408, 413, 429, 500, 502, 503, 504],
-  },
-});
-
-/**
- * HTTP client configured for JSON APIs.
- */
-export const httpJson = http.extend({
-  headers: {
-    Accept: "application/json",
-  },
-});

package/src/shared/index.ts

@@ -1,6 +0,0 @@
-export * from "./auth.js";
-export * from "./firebase.js";
-export * from "./fs.js";
-export * from "./http.js";
-export * from "./slug.js";
-export * from "./url.js";

package/src/shared/url.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractQueryParams, getBaseUrl, resolveUrl, resolveUrlWithParams } from "./url.js";
-
-describe("extractQueryParams", () => {
-  it("extracts query string with leading ?", () => {
-    expect(extractQueryParams("https://example.com/path?foo=bar")).toBe("?foo=bar");
-  });
-
-  it("extracts multiple query params", () => {
-    expect(extractQueryParams("https://example.com?a=1&b=2&c=3")).toBe("?a=1&b=2&c=3");
-  });
-
-  it("returns empty string when no query params", () => {
-    expect(extractQueryParams("https://example.com/path")).toBe("");
-  });
-
-  it("returns empty string for empty input", () => {
-    expect(extractQueryParams("")).toBe("");
-  });
-
-  it("handles URL with fragment after query", () => {
-    expect(extractQueryParams("https://example.com?foo=bar#section")).toBe("?foo=bar#section");
-  });
-
-  it("handles query string only (no path)", () => {
-    expect(extractQueryParams("?token=abc123")).toBe("?token=abc123");
-  });
-});
-
-describe("getBaseUrl", () => {
-  it("extracts base URL up to last slash", () => {
-    expect(getBaseUrl("https://cdn.example.com/videos/playlist.m3u8")).toBe(
-      "https://cdn.example.com/videos/"
-    );
-  });
-
-  it("handles URL with query params", () => {
-    expect(getBaseUrl("https://cdn.example.com/path/file.ts?token=abc")).toBe(
-      "https://cdn.example.com/path/"
-    );
-  });
-
-  it("handles root URL", () => {
-    expect(getBaseUrl("https://example.com/")).toBe("https://example.com/");
-  });
-
-  it("handles URL without trailing path", () => {
-    // Returns up to last slash (the // in https://)
-    expect(getBaseUrl("https://example.com")).toBe("https://");
-  });
-
-  it("handles empty string", () => {
-    expect(getBaseUrl("")).toBe("");
-  });
-
-  it("handles deeply nested paths", () => {
-    expect(getBaseUrl("https://cdn.com/a/b/c/d/file.m3u8")).toBe("https://cdn.com/a/b/c/d/");
-  });
-});
-
-describe("resolveUrl", () => {
-  it("returns absolute URL unchanged", () => {
-    expect(resolveUrl("https://other.com/file.ts", "https://cdn.com/")).toBe(
-      "https://other.com/file.ts"
-    );
-  });
-
-  it("resolves relative URL against base", () => {
-    expect(resolveUrl("segment001.ts", "https://cdn.example.com/videos/")).toBe(
-      "https://cdn.example.com/videos/segment001.ts"
-    );
-  });
-
-  it("handles http:// URLs", () => {
-    expect(resolveUrl("http://insecure.com/file.ts", "https://cdn.com/")).toBe(
-      "http://insecure.com/file.ts"
-    );
-  });
-
-  it("handles empty relative URL", () => {
-    expect(resolveUrl("", "https://cdn.com/path/")).toBe("https://cdn.com/path/");
-  });
-
-  it("handles relative path with subdirectory", () => {
-    expect(resolveUrl("sub/segment.ts", "https://cdn.com/videos/")).toBe(
-      "https://cdn.com/videos/sub/segment.ts"
-    );
-  });
-});
-
-describe("resolveUrlWithParams", () => {
-  it("appends query params to resolved URL", () => {
-    expect(resolveUrlWithParams("segment.ts", "https://cdn.com/", "?token=abc")).toBe(
-      "https://cdn.com/segment.ts?token=abc"
-    );
-  });
-
-  it("does not duplicate params if URL already has them", () => {
-    expect(resolveUrlWithParams("segment.ts?existing=1", "https://cdn.com/", "?token=abc")).toBe(
-      "https://cdn.com/segment.ts?existing=1"
-    );
-  });
-
-  it("handles absolute URL with params", () => {
-    expect(
-      resolveUrlWithParams("https://other.com/file.ts", "https://cdn.com/", "?token=abc")
-    ).toBe("https://other.com/file.ts?token=abc");
-  });
-
-  it("handles empty query params", () => {
-    expect(resolveUrlWithParams("segment.ts", "https://cdn.com/", "")).toBe(
-      "https://cdn.com/segment.ts"
-    );
-  });
-
-  it("works with complex signed URL tokens", () => {
-    const token = "?Policy=xxx&Signature=yyy&Key-Pair-Id=zzz";
-    expect(resolveUrlWithParams("video/720p.m3u8", "https://cdn.com/hls/", token)).toBe(
-      "https://cdn.com/hls/video/720p.m3u8?Policy=xxx&Signature=yyy&Key-Pair-Id=zzz"
-    );
-  });
-});

package/src/state/database.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractCommunitySlug } from "./database.js";
-
-describe("extractCommunitySlug", () => {
-  it("extracts slug from standard Skool URL", () => {
-    expect(extractCommunitySlug("https://www.skool.com/my-community")).toBe("my-community");
-  });
-
-  it("extracts slug from Skool URL without www", () => {
-    expect(extractCommunitySlug("https://skool.com/test-group")).toBe("test-group");
-  });
-
-  it("extracts slug from URL with path", () => {
-    expect(extractCommunitySlug("https://www.skool.com/my-community/classroom")).toBe(
-      "my-community"
-    );
-    expect(extractCommunitySlug("https://www.skool.com/my-community/classroom/lessons/123")).toBe(
-      "my-community"
-    );
-  });
-
-  it("extracts slug from URL with query params (includes params in slug)", () => {
-    // Note: current implementation doesn't strip query params
-    expect(extractCommunitySlug("https://www.skool.com/my-community?ref=abc")).toBe(
-      "my-community?ref=abc"
-    );
-  });
-
-  it("handles complex community names", () => {
-    expect(extractCommunitySlug("https://skool.com/the-best-community-ever-2024")).toBe(
-      "the-best-community-ever-2024"
-    );
-  });
-
-  it("returns 'unknown' for non-Skool URLs", () => {
-    expect(extractCommunitySlug("https://example.com/path")).toBe("unknown");
-    expect(extractCommunitySlug("https://youtube.com/channel/abc")).toBe("unknown");
-  });
-
-  it("returns 'unknown' for invalid URLs", () => {
-    expect(extractCommunitySlug("not-a-url")).toBe("unknown");
-    expect(extractCommunitySlug("")).toBe("unknown");
-  });
-
-  it("returns 'unknown' for Skool root URL", () => {
-    expect(extractCommunitySlug("https://www.skool.com/")).toBe("unknown");
-    expect(extractCommunitySlug("https://www.skool.com")).toBe("unknown");
-  });
-});