sea-dev 1.0.0

package/apps/main/scripts/login.ts

@@ -0,0 +1,78 @@
+import { chromium, type Page } from "playwright";
+
+/**
+ * Login script for automated testing
+ * This script handles the full login flow including sign-in and onboarding
+ */
+export async function login(page: Page) {
+  try {
+    console.log("Starting login process...");
+
+    // Navigate to the app
+    await page.goto("http://localhost:3000");
+    await page.waitForLoadState("networkidle");
+
+    const currentUrl = page.url();
+    console.log("Current URL:", currentUrl);
+
+    // Check if we're already logged in
+    if (!currentUrl.includes("sign-in") && !currentUrl.includes("sign-up")) {
+      console.log("✅ Already logged in");
+      return;
+    }
+
+    // If we're on sign-up page, go to sign-in
+    if (currentUrl.includes("sign-up")) {
+      console.log("On sign-up page, navigating to sign-in...");
+      await page.click('a[href="/sign-in"]');
+      await page.waitForLoadState("networkidle");
+    }
+
+    // Fill in login credentials
+    console.log("Filling in login credentials...");
+    await page.fill('input[data-testid="input-email"]', "claude-test@playwright.dev");
+    await page.fill('input[data-testid="input-password"]', "testpass123");
+
+    // Submit the form
+    console.log("Submitting login form...");
+    await page.click('button[data-testid="btn-submit"]');
+    await page.waitForLoadState("networkidle");
+
+    // Handle onboarding if needed
+    const onboardUrl = page.url();
+    if (onboardUrl.includes("/onboard")) {
+      console.log("On onboarding page, clicking Continue...");
+      await page.click('button[data-testid="btn-onboard-submit"]');
+      await page.waitForLoadState("networkidle");
+    }
+
+    console.log("✅ Login completed successfully");
+  } catch (error) {
+    console.error("❌ Login failed:", error);
+    throw error;
+  }
+}
+
+/**
+ * Standalone login function for testing
+ */
+export async function runLogin() {
+  const browser = await chromium.launch({ headless: false });
+  const page = await browser.newPage();
+
+  try {
+    await login(page);
+
+    // Take a screenshot for verification
+    await page.screenshot({ path: "./login-success.png" });
+    console.log("📸 Screenshot saved as login-success.png");
+  } finally {
+    await browser.close();
+  }
+}
+
+// Run if called directly
+// Note: This detection doesn't work perfectly in ESM, but keeping for backwards compatibility
+if (import.meta.url.endsWith(process.argv[1]?.replace(/^file:\/\//, "") ?? "")) {
+  runLogin().catch(console.error);
+}

package/apps/main/scripts/repl.ts

@@ -0,0 +1,61 @@
+/*
+ * This script provides a REPL for LLM access to the DB.
+ * Run with `pnpm run db:repl`
+ *
+ * Inside the REPL, the Drizzle ORM object can be accessed as `db`,
+ * the full schema as `schema` eg:
+ * ```
+ * const res = await db.select().from(schema.submission)
+ * console.log(res)
+ * ```
+ *
+ * You can also access a raw node-postgres pg client eg:
+ * ```
+ * const res = await client.query('SELECT $1::text as message', ['Hello world!'])
+ * console.log(res.rows[0].message)
+ * ```
+ *
+ * And you can use Playwright:
+ * ```
+ * const browser = await chromium.launch({ headless: false });
+ * const page = await browser.newPage();
+ * await page.goto("http://localhost:3000");
+ * // do whatever you like!
+ * ```
+ */
+
+import { db, schema } from "@sea/db";
+import repl from "node:repl";
+import { Client } from "pg";
+import { chromium } from "playwright";
+
+async function main() {
+  const dbUrl = process.env.DATABASE_URL;
+  if (!dbUrl) {
+    throw new Error("Need DATABASE_URL set");
+  }
+
+  const client = new Client({
+    connectionString: dbUrl,
+  });
+
+  try {
+    await client.connect();
+    const replServer = repl.start("> ");
+
+    replServer.context.db = db;
+    replServer.context.schema = schema;
+    replServer.context.client = client;
+    replServer.context.chromium = chromium;
+
+    replServer.on("exit", async () => {
+      await client.end();
+      process.exit(0);
+    });
+  } catch (_) {
+    await client.end();
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

package/apps/main/src/_foo.ts

@@ -0,0 +1,31 @@
+import { db, schema } from "@sea/db";
+import { invariant } from "@sea/util/invariant";
+import { and, asc, eq } from "drizzle-orm";
+
+async function getForm(formId: string) {
+  const form = await db.query.form.findFirst({
+    columns: { id: true, name: true, hint: true },
+    where: and(eq(schema.form.id, formId)),
+    with: {
+      groups: {
+        columns: { id: true, name: true, multi: true, hint: true },
+        with: {
+          fields: {
+            columns: { id: true, name: true, type: true, hint: true },
+            orderBy: asc(schema.formField.order),
+          },
+        },
+        orderBy: asc(schema.formGroup.order),
+      },
+    },
+  });
+  invariant(form, `no form found for ${formId}`);
+  return form;
+}
+
+async function main() {
+  const form = await getForm("skivgavkr4vnfo2nef4qw");
+  console.log(JSON.stringify(form, null, 2));
+}
+
+main().finally(() => process.exit(0));

package/apps/main/src/_tests/db.test.ts

@@ -0,0 +1,19 @@
+import { resetTestDb } from "@/_tests/mock-db"; // Must always be the first import
+
+import { db, schema } from "@sea/db";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+describe("testDb", () => {
+  beforeEach(async () => {
+    await resetTestDb();
+    vi.stubEnv("NODE_ENV", "test");
+  });
+
+  it("test db works", async () => {
+    await db
+      .insert(schema.verification)
+      .values({ identifier: "", value: "", expiresAt: new Date() });
+    const res = await db.query.verification.findMany();
+    expect(res).toHaveLength(1);
+  });
+});

package/apps/main/src/_tests/mock-db.ts

@@ -0,0 +1,60 @@
+// Copied from:
+// https://github.com/drizzle-team/drizzle-orm/discussions/4373#discussioncomment-12743792
+
+import { PGlite } from "@electric-sql/pglite";
+import { vector } from "@electric-sql/pglite/vector";
+import * as schema from "@sea/db/schema";
+import type * as DrizzleKit from "drizzle-kit/api";
+import { is } from "drizzle-orm";
+import { PgTable } from "drizzle-orm/pg-core";
+import { drizzle, type PgliteDatabase } from "drizzle-orm/pglite";
+import { createRequire } from "node:module";
+import { afterAll, vi } from "vitest";
+
+// Workaround for https://github.com/drizzle-team/drizzle-orm/issues/2853
+const require = createRequire(import.meta.url);
+const { generateDrizzleJson, generateMigration } = require("drizzle-kit/api") as typeof DrizzleKit;
+
+// Workaround for https://github.com/drizzle-team/drizzle-orm/issues/3913
+async function pushSchema(db: PgliteDatabase<typeof schema>) {
+  const prevJson = generateDrizzleJson({});
+  const curJson = generateDrizzleJson(schema, prevJson.id);
+  const statements = await generateMigration(prevJson, curJson);
+  for (const statement of statements) {
+    await db.execute(statement);
+  }
+}
+
+let client: PGlite;
+
+// Replace the database with an in-memory database (Pglite)
+vi.mock("@sea/db", async () => {
+  client = new PGlite({ extensions: { vector } });
+  await client.exec("CREATE EXTENSION IF NOT EXISTS vector;");
+  const db = drizzle(client, { schema });
+  await pushSchema(db);
+  return { db, schema };
+});
+
+afterAll(async () => {
+  resetTestDb();
+  await client?.close();
+});
+
+export async function resetTestDb() {
+  if (!client) {
+    return;
+  }
+
+  const tables = Object.values(schema)
+    .filter((table) => is(table, PgTable) && "dbName" in table)
+    .map((table) => table.dbName);
+
+  for (const table of tables) {
+    try {
+      await client.exec(`TRUNCATE TABLE "${table}" CASCADE;`);
+    } catch (error) {
+      console.warn(`Could not truncate table ${table}:`, error);
+    }
+  }
+}

package/apps/main/src/client.tsx

@@ -0,0 +1,13 @@
+import { StartClient } from "@tanstack/react-start";
+import { StrictMode } from "react";
+import { hydrateRoot } from "react-dom/client";
+import { createRouter } from "./router";
+
+const router = createRouter();
+
+hydrateRoot(
+  document,
+  <StrictMode>
+    <StartClient router={router} />
+  </StrictMode>,
+);

package/apps/main/src/clients/loops.ts

@@ -0,0 +1,13 @@
+import { getAppConfig } from "@/lib/config";
+import { createLoopsClient } from "@sea/clients/loops";
+
+const config = getAppConfig();
+
+const loopsClient = createLoopsClient({
+  apiKey: config.loops.apiKey,
+  baseUrl: config.baseUrl,
+});
+
+// Re-export methods for backward compatibility
+export const sendEmailOtp = loopsClient.sendEmailOtp.bind(loopsClient);
+export const sendEmailInvite = loopsClient.sendEmailInvite.bind(loopsClient);

package/apps/main/src/clients/polar.ts

@@ -0,0 +1,12 @@
+import { getAppConfig } from "@/lib/config";
+import { createPolarClient } from "@sea/clients/polar";
+
+const {
+  polar: { accessToken, server },
+} = getAppConfig();
+
+const polarClientInstance = createPolarClient({ accessToken, server });
+
+// Re-export for backward compatibility
+export const polarClient = polarClientInstance.client;
+export const getCustomer = polarClientInstance.getCustomer.bind(polarClientInstance);

package/apps/main/src/clients/posthog.ts

@@ -0,0 +1,12 @@
+import { getConfigIso } from "@/lib/config-iso";
+import { captureEvent as captureEventFn, createPostHogClient } from "@sea/clients/posthog";
+
+const configIso = getConfigIso();
+
+export const posthog = createPostHogClient({
+  key: configIso.posthog.key,
+  host: configIso.posthog.host,
+});
+
+// Re-export captureEvent with posthog instance bound
+export const captureEvent = captureEventFn.bind(null, posthog);

package/apps/main/src/components/chat/chat-context.tsx

@@ -0,0 +1,99 @@
+import { useChat, type UseChatHelpers } from "@ai-sdk/react";
+import type { ChatType } from "@sea/core/chat/types";
+import { nanoid } from "@sea/util/id";
+import { useRouter } from "@tanstack/react-router";
+import { DefaultChatTransport, type UIDataTypes, type UIMessage, type UITools } from "ai";
+import {
+  createContext,
+  useContext,
+  useState,
+  type Dispatch,
+  type ReactNode,
+  type SetStateAction,
+} from "react";
+
+type ChatContextValue = UseChatHelpers<UIMessage<unknown, UIDataTypes, UITools>> & {
+  chatIsLoading: boolean;
+  setChatIsLoading: Dispatch<SetStateAction<boolean>>;
+};
+
+const ChatContext = createContext<ChatContextValue | null>(null);
+
+export function useChatContext() {
+  const context = useContext(ChatContext);
+  if (!context) {
+    throw new Error("useChatContext must be used within ChatProvider");
+  }
+  return context;
+}
+
+// Type for navigation actions returned by tools
+export interface ReportNavigationAction {
+  type: "navigate";
+  status?: "all" | "final" | "draft" | "latest";
+  dealIds?: string[];
+}
+
+export function ChatProvider({
+  children,
+  conversationId,
+  initMessages,
+  api = "/api/chat/member",
+  chatType = "default",
+  apiKey,
+  // dealId,
+  // statusFilter,
+  // dealIds,
+  // formId,
+  // formName,
+  // onNavigationAction,
+}: {
+  children: ReactNode;
+  conversationId: string;
+  initMessages: UIMessage[];
+  api?: string;
+  chatType?: ChatType;
+  apiKey?: string;
+  // dealId?: string;
+  // statusFilter?: "all" | "final" | "draft" | "latest";
+  // dealIds?: string[];
+  // formId?: string;
+  // formName?: string;
+  // onNavigationAction?: (action: ReportNavigationAction) => void;
+}) {
+  const router = useRouter();
+  const [chatIsLoading, setChatIsLoading] = useState(false);
+
+  const chatProps = useChat({
+    transport: new DefaultChatTransport({
+      api,
+      prepareSendMessagesRequest({ messages, body }) {
+        return {
+          body: {
+            message: messages.at(-1),
+            conversationId,
+            chatType,
+            apiKey,
+            // dealId,
+            // statusFilter,
+            // dealIds,
+            // formId,
+            // formName,
+            ...body,
+          },
+        };
+      },
+    }),
+    id: conversationId,
+    messages: initMessages,
+    generateId: nanoid,
+    experimental_throttle: 30,
+    onToolCall: () => router.invalidate(),
+  });
+
+  return (
+    <ChatContext.Provider value={{ ...chatProps, chatIsLoading, setChatIsLoading }}>
+      {children}
+    </ChatContext.Provider>
+  );
+}

package/apps/main/src/components/chat/chat-messages.tsx

@@ -0,0 +1,184 @@
+import { MessageComponent } from "@/components/chat/chat";
+import { ModelSelect } from "@/components/sidebar/model-select";
+import { LoadingDotsIcon } from "@/components/svg/loading";
+import { useChat } from "@ai-sdk/react";
+import type { ChatModel } from "@sea/db/schema";
+import type { ConversationHydrated } from "@sea/db/types";
+import { Button } from "@sea/ui/components/ui/button";
+import { ChatTextarea } from "@sea/ui/components/ui/textarea";
+import { nanoid } from "@sea/util/id";
+import { useRouter } from "@tanstack/react-router";
+import { DefaultChatTransport, type UIMessage } from "ai";
+import { ArrowUpIcon, BotIcon, Loader2Icon } from "lucide-react";
+import { type FormEvent, useEffect, useRef, useState } from "react";
+
+const ERROR_MSG = "Error in LLM backend";
+
+export function ChatMessages({
+  conversation,
+  conversationId,
+  chatIsLoading,
+  chatModel = "gpt-4.1",
+}: {
+  conversation: ConversationHydrated;
+  conversationId: string;
+  chatIsLoading: boolean;
+  chatModel?: ChatModel;
+}) {
+  const router = useRouter();
+  const [input, setInput] = useState("");
+  const [citationModalOpen, setCitationModalOpen] = useState(false);
+  const [selectedCitationId, setSelectedCitationId] = useState<string | null>(null);
+  const [chatIsLoadingState, setChatIsLoadingState] = useState(chatIsLoading);
+
+  const handleCitationClick = (citationId: string) => {
+    setSelectedCitationId(citationId);
+    setCitationModalOpen(true);
+  };
+
+  const { messages, error, setMessages, sendMessage, status, stop } = useChat({
+    transport: new DefaultChatTransport({
+      api: "/api/chat/agent",
+      prepareSendMessagesRequest({ messages }) {
+        return {
+          body: { message: messages.at(-1), conversationId, chatType: "pipeline" },
+        };
+      },
+    }),
+    id: conversationId,
+    messages: conversation.messages as UIMessage[],
+    generateId: nanoid,
+    // Throttle updates to prevent "Maximum update depth exceeded" errors during long streams
+    experimental_throttle: 500,
+    onFinish: () => {
+      // Only invalidate after all tools are done and the conversation is complete
+      setTimeout(() => router.invalidate(), 100);
+    },
+  });
+  const isLoading = status === "submitted" || status === "streaming";
+
+  // Sync messages when conversation updates from polling
+  useEffect(() => {
+    const loaderMessages = conversation.messages as UIMessage[];
+    // Only update if we have new messages
+    if (loaderMessages.length > messages.length) {
+      setMessages(loaderMessages);
+    }
+  }, [conversation.messages, messages.length, setMessages]);
+
+  useEffect(() => {
+    if (error) {
+      console.error("[AgentChatMessages] Error:", error);
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: nanoid(),
+          role: "assistant",
+          parts: [{ type: "text", text: ERROR_MSG }],
+        },
+      ]);
+    }
+  }, [error]);
+
+  const instructions = `
+How can I help you today?`;
+
+  const messagesRef = useRef<HTMLDivElement>(null);
+  const shouldAutoScrollRef = useRef(true);
+
+  useEffect(() => {
+    const container = messagesRef.current;
+    if (!container) return;
+
+    const handleScroll = () => {
+      const threshold = 80;
+      const atBottom =
+        container.scrollHeight - container.scrollTop - container.clientHeight <= threshold;
+      shouldAutoScrollRef.current = atBottom;
+    };
+
+    handleScroll();
+    container.addEventListener("scroll", handleScroll);
+
+    return () => {
+      container.removeEventListener("scroll", handleScroll);
+    };
+  }, []);
+
+  useEffect(() => {
+    const container = messagesRef.current;
+    if (!container || !shouldAutoScrollRef.current) return;
+    container.scrollTo({
+      top: container.scrollHeight,
+      behavior: "smooth",
+    });
+  }, [messages, isLoading]);
+
+  const onSubmit = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    sendMessage({ text: input });
+    setInput("");
+  };
+
+  return (
+    <div className="flex h-full flex-col">
+      <div className="w-full p-2">
+        <ModelSelect
+          conversationId={conversationId}
+          chatModel={chatModel}
+          setChatIsLoading={setChatIsLoadingState}
+        />
+      </div>
+      <div ref={messagesRef} className="flex-1 overflow-y-auto">
+        <div className="mx-auto w-full max-w-3xl space-y-4 p-4">
+          {messages.length === 0 && (
+            <div className="text-muted-foreground my-8 text-center">
+              <div className="bg-card mx-auto max-w-md rounded-lg p-6">
+                <BotIcon className="text-primary mx-auto mb-4 h-8 w-8" />
+                <p className="whitespace-pre-line">{instructions}</p>
+              </div>
+            </div>
+          )}
+          <div className="space-y-4">
+            {messages.map((message) => (
+              <MessageComponent
+                key={message.id}
+                message={message}
+                variant="agent"
+                onCitationClick={handleCitationClick}
+              />
+            ))}
+            {isLoading && (
+              <div className="text-brand-foreground mx-auto my-4">
+                <LoadingDotsIcon />
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+
+      <div className="bg-background w-full p-2">
+        <form onSubmit={onSubmit} className="flex w-full space-x-2">
+          <ChatTextarea
+            value={input}
+            onChange={(e) => setInput(e.target.value)}
+            autoFocus={true}
+            isLoading={isLoading}
+            disabled={chatIsLoadingState}
+            placeholder="Reply..."
+            className="bg-background text-foreground z-10 w-full max-w-full resize-none border-0 ring-transparent! outline-hidden! dark:ring-0!"
+          />
+          <Button size="icon" disabled={isLoading}>
+            <ArrowUpIcon />
+          </Button>
+        </form>
+      </div>
+
+      {chatIsLoadingState && (
+        <div className="bg-muted/60 fixed inset-0 flex items-center justify-center">
+          <Loader2Icon className="h-6 w-6 animate-spin" />
+        </div>
+      )}
+    </div>
+  );
+}