business-stack 0.1.0

package/frontend/web/src/lib/alpha-webhook/connectors/wabridge-delivery.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import type { AlertCreatedPayload } from "../types";
+import { formatAlertWhatsAppMessage } from "./wabridge-delivery";
+
+const minimal: AlertCreatedPayload = {
+  _id: "674a1b2c3d4e5f6789012345",
+  alert_type: "price_spike",
+  date: "2025-04-01T10:30:00.000Z",
+  r2_key: "alerts/x.opus",
+  alert_string: "Notable price action on AAPL.",
+  symbol: "AAPL",
+  user_id: "u1",
+};
+
+describe("formatAlertWhatsAppMessage", () => {
+  it("includes symbol, type, body, date, and id", () => {
+    const text = formatAlertWhatsAppMessage(minimal);
+    expect(text).toContain("*AAPL*");
+    expect(text).toContain("price_spike");
+    expect(text).toContain("Notable price action");
+    expect(text).toContain("2025-04-01T10:30:00.000Z");
+    expect(text).toContain("674a1b2c3d4e5f6789012345");
+  });
+
+  it("adds symbol_info lines when present", () => {
+    const withInfo: AlertCreatedPayload = {
+      ...minimal,
+      symbol_info: {
+        symbol: "MSFT",
+        name: "Microsoft Corporation",
+        price: 410.25,
+        percentage_change: 1.42,
+      },
+    };
+    const text = formatAlertWhatsAppMessage(withInfo);
+    expect(text).toContain("Microsoft Corporation");
+    expect(text).toContain("410.25");
+    expect(text).toContain("+1.42%");
+  });
+});

package/frontend/web/src/lib/alpha-webhook/connectors/wabridge-delivery.ts

@@ -0,0 +1,78 @@
+import type { AlertCreatedPayload } from "../types";
+
+/** Plain-text body for WhatsApp (*bold* is optional WA formatting). */
+export function formatAlertWhatsAppMessage(
+  payload: AlertCreatedPayload,
+): string {
+  const parts: string[] = [];
+  const headline = payload.symbol
+    ? `*${payload.symbol}* · ${payload.alert_type}`
+    : payload.alert_type;
+  parts.push(
+    headline,
+    "",
+    payload.alert_string,
+    "",
+    `🕐 ${payload.date}`,
+    `id: ${payload._id}`,
+  );
+
+  const info = payload.symbol_info;
+  if (info) {
+    if (info.name) parts.push("", info.name);
+    if (info.price != null) {
+      const ch =
+        info.percentage_change != null
+          ? ` (${info.percentage_change >= 0 ? "+" : ""}${info.percentage_change}%)`
+          : "";
+      parts.push(`Price: ${info.price}${ch}`);
+    }
+  }
+
+  return parts.join("\n").trim();
+}
+
+let missingBaseUrlLogged = false;
+
+export type WabridgeDeliveryOptions = {
+  baseUrl?: string;
+  phone?: string;
+};
+
+/**
+ * POSTs to a running [WABridge](https://github.com/marketcalls/wabridge) server.
+ * Uses options first, then `WABRIDGE_BASE_URL` / `WABRIDGE_PHONE` env.
+ */
+export async function sendWhatsAppViaWabridge(
+  message: string,
+  options?: WabridgeDeliveryOptions,
+): Promise<void> {
+  const rawBase =
+    options?.baseUrl?.trim() || process.env.WABRIDGE_BASE_URL?.trim();
+  if (!rawBase) {
+    if (!missingBaseUrlLogged) {
+      missingBaseUrlLogged = true;
+      console.warn(
+        "[wabridge] WABridge base URL not set; WhatsApp delivery skipped. Configure integration settings or WABRIDGE_BASE_URL.",
+      );
+    }
+    return;
+  }
+
+  const base = rawBase.replace(/\/$/, "");
+  const phone = options?.phone?.trim() || process.env.WABRIDGE_PHONE?.trim();
+  const path = phone ? "/send" : "/send/self";
+  const body = phone ? { phone, message } : { message };
+
+  const res = await fetch(`${base}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(25_000),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`WABridge HTTP ${res.status}: ${text.slice(0, 300)}`);
+  }
+}

package/frontend/web/src/lib/alpha-webhook/connectors/wabridge.ts

@@ -0,0 +1,30 @@
+import type { ResolvedIntegrations } from "@/lib/integrations-config";
+import type { AlertCreatedPayload } from "../types";
+import type { AlertConnector } from "./types";
+import {
+  formatAlertWhatsAppMessage,
+  sendWhatsAppViaWabridge,
+} from "./wabridge-delivery";
+
+/**
+ * WhatsApp via [WABridge](https://github.com/marketcalls/wabridge) HTTP API.
+ * Disabled when resolved config has `wabridgeEnabled: false` (SQLite, env, or both).
+ */
+export function createWabridgeConnector(
+  cfg: ResolvedIntegrations,
+): AlertConnector | null {
+  if (!cfg.wabridgeEnabled) {
+    return null;
+  }
+
+  return {
+    id: "wabridge",
+    async deliver(payload: AlertCreatedPayload) {
+      const message = formatAlertWhatsAppMessage(payload);
+      await sendWhatsAppViaWabridge(message, {
+        baseUrl: cfg.wabridgeBaseUrl,
+        phone: cfg.wabridgePhone,
+      });
+    },
+  };
+}

package/frontend/web/src/lib/alpha-webhook/handler.ts

@@ -0,0 +1,12 @@
+import { deliverAlertPayload } from "./connectors/registry";
+import type { AlertCreatedPayload } from "./types";
+
+/**
+ * Dispatches to registered alert connectors (see `connectors/registry.ts`).
+ * The webhook route awaits this before responding so serverless hosts finish outbound work.
+ */
+export async function handleAlertCreated(
+  payload: AlertCreatedPayload,
+): Promise<void> {
+  await deliverAlertPayload(payload);
+}

package/frontend/web/src/lib/alpha-webhook/signature.test.ts

@@ -0,0 +1,33 @@
+import { createHmac } from "node:crypto";
+import { describe, expect, it } from "vitest";
+import { isValidAlphaWebhookSignature } from "./signature";
+
+function sign(rawBody: string, secret: string): string {
+  return createHmac("sha256", secret).update(rawBody, "utf8").digest("hex");
+}
+
+describe("isValidAlphaWebhookSignature", () => {
+  it("accepts a valid lowercase hex signature", () => {
+    const body =
+      '{"_id":"x","alert_type":"t","date":"d","r2_key":"k","alert_string":"s"}';
+    const secret = "my-secret";
+    const sig = sign(body, secret);
+    expect(isValidAlphaWebhookSignature(body, secret, sig)).toBe(true);
+  });
+
+  it("rejects wrong secret", () => {
+    const body = "{}";
+    const sig = sign(body, "a");
+    expect(isValidAlphaWebhookSignature(body, "b", sig)).toBe(false);
+  });
+
+  it("rejects tampered body", () => {
+    const body = '{"a":1}';
+    const sig = sign(body, "s");
+    expect(isValidAlphaWebhookSignature('{"a":2}', "s", sig)).toBe(false);
+  });
+
+  it("rejects length mismatch without throwing", () => {
+    expect(isValidAlphaWebhookSignature("{}", "s", "abc")).toBe(false);
+  });
+});

package/frontend/web/src/lib/alpha-webhook/signature.ts

@@ -0,0 +1,21 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+/**
+ * Verifies X-Alpha-Signature: HMAC-SHA256(secret, raw UTF-8 body) as lowercase hex.
+ * Uses timing-safe comparison; mismatched lengths return false without calling timingSafeEqual.
+ */
+export function isValidAlphaWebhookSignature(
+  rawBody: string,
+  secret: string,
+  signatureHeader: string,
+): boolean {
+  const expected = createHmac("sha256", secret)
+    .update(rawBody, "utf8")
+    .digest("hex");
+  const a = Buffer.from(expected, "utf8");
+  const b = Buffer.from(signatureHeader.trim().toLowerCase(), "utf8");
+  if (a.length !== b.length) {
+    return false;
+  }
+  return timingSafeEqual(a, b);
+}

package/frontend/web/src/lib/alpha-webhook/types.ts

@@ -0,0 +1,23 @@
+/** Payload for X-Alpha-Webhook-Event: alert.created */
+export type AlertCreatedSymbolInfo = {
+  symbol: string;
+  name?: string;
+  basic_industry?: string;
+  "52_week_low"?: number;
+  "52_week_high"?: number;
+  image?: string;
+  market_cap?: number;
+  price?: number;
+  percentage_change?: number;
+};
+
+export type AlertCreatedPayload = {
+  _id: string;
+  alert_type: string;
+  date: string;
+  r2_key: string;
+  alert_string: string;
+  symbol?: string;
+  user_id?: string;
+  symbol_info?: AlertCreatedSymbolInfo;
+};

package/frontend/web/src/lib/auth-client.ts

@@ -0,0 +1,23 @@
+import { createAuthClient } from "better-auth/react";
+
+function normalizeBaseUrl(url: string): string {
+  return url.replace(/\/$/, "");
+}
+
+function authBaseUrl(): string {
+  const raw = process.env.NEXT_PUBLIC_AUTH_BASE_URL?.trim();
+  if (raw) {
+    return normalizeBaseUrl(raw);
+  }
+  if (typeof window !== "undefined") {
+    return window.location.origin;
+  }
+  return "http://localhost:3000";
+}
+
+export const authClient = createAuthClient({
+  baseURL: authBaseUrl(),
+  fetchOptions: {
+    credentials: "include",
+  },
+});

package/frontend/web/src/lib/integrations-config.ts

@@ -0,0 +1,125 @@
+import "server-only";
+
+export type IntegrationsFromGateway = {
+  alphaWebhookSecret: string | null;
+  wabridgeBaseUrl: string | null;
+  wabridgePhone: string | null;
+  wabridgeEnabled: string | null;
+  geminiApiKey: string | null;
+};
+
+export type ResolvedIntegrations = {
+  alphaWebhookSecret: string | null;
+  wabridgeBaseUrl: string | undefined;
+  wabridgePhone: string | undefined;
+  wabridgeEnabled: boolean;
+  geminiApiKey: string | null;
+};
+
+const gatewayInternal =
+  process.env.AUTH_GATEWAY_INTERNAL_URL?.trim() || "http://127.0.0.1:3001";
+
+let cache: { at: number; value: IntegrationsFromGateway } | null = null;
+const TTL_MS = 60_000;
+
+export function invalidateIntegrationsConfigCache(): void {
+  cache = null;
+}
+
+function envFallback(): IntegrationsFromGateway {
+  const wabridgeEnabledEnv = process.env.WABRIDGE_ENABLED?.trim();
+  let wabridgeEnabled: string | null = null;
+  if (wabridgeEnabledEnv === "0" || wabridgeEnabledEnv === "false") {
+    wabridgeEnabled = "false";
+  } else if (wabridgeEnabledEnv === "1" || wabridgeEnabledEnv === "true") {
+    wabridgeEnabled = "true";
+  }
+  return {
+    alphaWebhookSecret: process.env.ALPHA_WEBHOOK_SECRET?.trim() ?? null,
+    wabridgeBaseUrl: process.env.WABRIDGE_BASE_URL?.trim() ?? null,
+    wabridgePhone: process.env.WABRIDGE_PHONE?.trim() ?? null,
+    wabridgeEnabled,
+    geminiApiKey: process.env.GEMINI_API_KEY?.trim() ?? null,
+  };
+}
+
+async function fetchFromGateway(): Promise<IntegrationsFromGateway | null> {
+  const bearer = process.env.INTEGRATIONS_INTERNAL_SECRET?.trim();
+  if (!bearer) {
+    return null;
+  }
+  try {
+    const res = await fetch(`${gatewayInternal}/internal/integrations`, {
+      headers: { Authorization: `Bearer ${bearer}` },
+      cache: "no-store",
+    });
+    if (!res.ok) {
+      return null;
+    }
+    return (await res.json()) as IntegrationsFromGateway;
+  } catch {
+    return null;
+  }
+}
+
+/** Plaintext integration values for server routes (webhooks, connectors). Cached briefly. */
+export async function getIntegrationsConfig(): Promise<ResolvedIntegrations> {
+  const now = Date.now();
+  let raw: IntegrationsFromGateway;
+
+  if (cache && now - cache.at < TTL_MS) {
+    raw = cache.value;
+  } else {
+    const fromGateway = await fetchFromGateway();
+    if (fromGateway) {
+      raw = fromGateway;
+    } else {
+      raw = envFallback();
+    }
+    cache = { at: now, value: raw };
+  }
+
+  const envFb = envFallback();
+  const alpha =
+    raw.alphaWebhookSecret?.trim() || envFb.alphaWebhookSecret?.trim() || null;
+  const base =
+    raw.wabridgeBaseUrl?.trim() || envFb.wabridgeBaseUrl?.trim() || undefined;
+  const phone =
+    raw.wabridgePhone?.trim() || envFb.wabridgePhone?.trim() || undefined;
+
+  const wabridgeEnabled = resolveWabridgeEnabled(
+    raw.wabridgeEnabled,
+    envFb.wabridgeEnabled,
+  );
+
+  const gemini = raw.geminiApiKey?.trim() || envFb.geminiApiKey?.trim() || null;
+
+  return {
+    alphaWebhookSecret: alpha,
+    wabridgeBaseUrl: base,
+    wabridgePhone: phone,
+    wabridgeEnabled,
+    geminiApiKey: gemini,
+  };
+}
+
+function resolveWabridgeEnabled(
+  db: string | null,
+  env: string | null,
+): boolean {
+  const envRaw = process.env.WABRIDGE_ENABLED?.trim();
+  if (envRaw === "0" || envRaw === "false") {
+    return false;
+  }
+  if (envRaw === "1" || envRaw === "true") {
+    return true;
+  }
+  const merged = db ?? env;
+  if (merged === "false") {
+    return false;
+  }
+  if (merged === "true") {
+    return true;
+  }
+  return true;
+}

package/frontend/web/src/lib/ui-utills.tsx

@@ -0,0 +1,90 @@
+import type { ComponentPropsWithoutRef, ElementType, ReactNode } from "react";
+import { cn } from "./utils";
+
+type MaxWidthContainerProps<T extends ElementType = "main"> = {
+  /**
+   * The HTML element to render. Defaults to "main".
+   */
+  as?: T;
+  /**
+   * Maximum width variant. Defaults to "2xl".
+   * - "sm": max-w-screen-sm (640px)
+   * - "md": max-w-screen-md (768px)
+   * - "lg": max-w-screen-lg (1024px)
+   * - "xl": max-w-screen-xl (1280px)
+   * - "2xl": max-w-screen-2xl (1536px)
+   * - "full": no max-width constraint
+   */
+  maxWidth?: "sm" | "md" | "lg" | "xl" | "2xl" | "full";
+  /**
+   * Padding variant. Defaults to "default".
+   * - "none": no padding
+   * - "sm": px-2.5 (10px)
+   * - "default": px-2.5 md:px-20 (10px mobile, 80px desktop)
+   * - "lg": px-4 md:px-24 (16px mobile, 96px desktop)
+   */
+  padding?: "none" | "sm" | "default" | "lg";
+  /**
+   * Additional CSS classes to apply.
+   */
+  className?: string;
+  /**
+   * Child elements to render inside the container.
+   */
+  children: ReactNode;
+} & ComponentPropsWithoutRef<T>;
+
+const maxWidthClasses = {
+  sm: "max-w-screen-sm",
+  md: "max-w-screen-md",
+  lg: "max-w-screen-lg",
+  xl: "max-w-screen-xl",
+  "2xl": "max-w-screen-2xl",
+  full: "",
+} as const;
+
+const paddingClasses = {
+  none: "",
+  sm: "px-2.5",
+  default: "px-2.5 md:px-20",
+  lg: "px-4 md:px-24",
+} as const;
+
+/**
+ * A flexible container component that centers content with a maximum width.
+ *
+ * @example
+ * ```tsx
+ * <MaxWidthContainer>
+ *   <h1>Centered content</h1>
+ * </MaxWidthContainer>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * <MaxWidthContainer as="div" maxWidth="lg" padding="sm">
+ *   <p>Custom container</p>
+ * </MaxWidthContainer>
+ * ```
+ */
+export default function MaxWidthContainer<T extends ElementType = "main">({
+  as,
+  maxWidth = "2xl",
+  padding = "default",
+  className,
+  children,
+  ...props
+}: MaxWidthContainerProps<T>) {
+  const Component = as ?? ("main" as ElementType);
+  const maxWidthClass = maxWidthClasses[maxWidth];
+  const paddingClass = paddingClasses[padding];
+
+  return (
+    <Component
+      className={cn("mx-auto w-full", maxWidthClass, paddingClass, className)}
+      {...props}
+    >
+      {children}
+    </Component>
+  );
+}

package/frontend/web/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/frontend/web/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"],
+      "~/*": ["./src/*"]
+    },
+    "strictNullChecks": true
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}