sea-dev 1.0.0

package/libs/clients/src/gcp.ts

@@ -0,0 +1,220 @@
+import type { Storage } from "@google-cloud/storage";
+import type { GCPConfig } from "@sea/config";
+
+export class GCPClient {
+  private storageClient?: Storage;
+  private config: GCPConfig;
+
+  /**
+   * Creates a new GCP client instance with the provided configuration
+   * @param config - The GCP configuration including credentials, project ID, and service settings
+   */
+  constructor(config: GCPConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Lazy-loads and returns a Google Cloud Storage client instance
+   * Uses dynamic import to avoid bundling the entire package until needed
+   * @returns Promise<Storage> - The Google Cloud Storage client
+   * @private
+   */
+  private async getStorageClient(): Promise<Storage> {
+    if (!this.storageClient) {
+      const { Storage } = await import("@google-cloud/storage");
+      this.storageClient = new Storage({
+        projectId: this.config.projectId,
+        keyFilename: this.config.serviceAccountCredentials,
+      });
+    }
+    return this.storageClient;
+  }
+
+  /**
+   * Uploads a file to GCP Storage and generates a signed URL
+   * @param file - The file buffer to upload
+   * @param fileName - The unique identifier for the file
+   * @returns Promise<boolean> - Whether the file was uploaded successfully
+   */
+  public async uploadFile(
+    file: Buffer,
+    fileName: string,
+    fileType: string,
+  ): Promise<boolean> {
+    try {
+      const storageClient = await this.getStorageClient();
+      const bucket = storageClient.bucket(
+        this.config.storage.documentBucketName,
+      );
+      const fileObject = bucket.file(fileName);
+      await fileObject.save(file, { metadata: { contentType: fileType } });
+
+      return true;
+    } catch (error) {
+      console.error("Error uploading file and generating signed URL:", error);
+      throw new Error(
+        `File upload failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      );
+    }
+  }
+
+  /**
+   * Downloads a file from GCP Storage
+   * @param blobName - The blob name/path in the bucket
+   * @returns Promise<Buffer> - The file contents as a buffer
+   * @throws Error if the download fails
+   */
+  public async downloadFile(blobName: string): Promise<Buffer> {
+    try {
+      const storageClient = await this.getStorageClient();
+      const bucket = storageClient.bucket(
+        this.config.storage.documentBucketName,
+      );
+      const file = bucket.file(blobName);
+      const [buffer] = await file.download();
+      return buffer;
+    } catch (error) {
+      console.error("Error downloading file:", error);
+      throw new Error(
+        `Failed to download file ${blobName}: ${error instanceof Error ? error.message : "Unknown error"}`,
+      );
+    }
+  }
+
+  /**
+   * Checks if a Google Cloud Storage signed URL has expired
+   * Supports both v2 and v4 signed URL formats
+   * @param url - The signed URL to check
+   * @returns Promise<boolean> - True if the URL has expired, false otherwise
+   * @throws Error if the URL format is not recognized or missing expiry parameters
+   */
+  public async checkUrlExpiry(url: string): Promise<boolean> {
+    const u = new URL(url);
+    const now = new Date();
+
+    // For v4 signed URLs
+    if (
+      u.searchParams.has("X-Goog-Date") &&
+      u.searchParams.has("X-Goog-Expires")
+    ) {
+      const d = u.searchParams.get("X-Goog-Date");
+      if (!d) {
+        throw new Error("URL does not contain an 'X-Goog-Date' parameter.");
+      }
+      const start = Date.parse(
+        `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}T${d.slice(9, 11)}:${d.slice(11, 13)}:${d.slice(13, 15)}Z`,
+      );
+      const duration = Number(u.searchParams.get("X-Goog-Expires")) * 1000;
+      return now >= new Date(start + duration);
+    }
+
+    // For v2 signed URLs
+    if (u.searchParams.has("Expires")) {
+      return now >= new Date(Number(u.searchParams.get("Expires")) * 1000);
+    }
+
+    throw new Error("URL does not contain a signed expiry parameter.");
+  }
+
+  /**
+   * Generates a signed URL for reading a file from Google Cloud Storage
+   * @param fileName - The name of the file in the storage bucket
+   * @param expireInHours - Number of hours until the URL expires (default: 12)
+   * @returns Promise<{url: string, expiry: Date}> - The signed URL and its expiration date
+   */
+  public async getSignedUrl(
+    fileName: string,
+    expireInHours = 12,
+  ): Promise<{ url: string; expiry: Date }> {
+    const storageClient = await this.getStorageClient();
+    const bucket = storageClient.bucket(this.config.storage.documentBucketName);
+    const fileObject = bucket.file(fileName);
+    const [url] = await fileObject.getSignedUrl({
+      version: "v4",
+      action: "read",
+      expires: Date.now() + expireInHours * 60 * 60 * 1000,
+    });
+
+    return {
+      url,
+      expiry: new Date(Date.now() + expireInHours * 60 * 60 * 1000),
+    };
+  }
+
+  /**
+   * Downloads JSON from a GCS URI
+   * @param uri - The GCS URI of the JSON file to fetch
+   * @returns Promise<object> - The parsed JSON document
+   * @throws Error if the file is not found or cannot be parsed
+   */
+  public async getExtractionOutput(uri: string): Promise<object> {
+    const storageClient = await this.getStorageClient();
+    const { bucket, prefix } = this.parseGcsUri(uri);
+    const file = storageClient.bucket(bucket).file(prefix);
+    const [data] = await file.download();
+    return JSON.parse(data.toString("utf8"));
+  }
+
+  /**
+   * Saves extraction results to GCS
+   * @public
+   */
+  public async storeObjects(
+    outputPath: string,
+    extractedDocs: Record<string, object>,
+  ): Promise<string[]> {
+    const storageClient = await this.getStorageClient();
+    const outputBucket = storageClient.bucket(
+      this.config.storage.outputBucketName,
+    );
+
+    const outputPaths = await Promise.all(
+      Object.entries(extractedDocs).map(async ([key, doc]) => {
+        const chunkPath = `${outputPath}/${key}.json`;
+        await outputBucket.file(chunkPath).save(JSON.stringify(doc), {
+          contentType: "application/json",
+        });
+        return chunkPath;
+      }),
+    );
+
+    return outputPaths;
+  }
+
+  /**
+   * Deletes all files in a GCS folder
+   * @public
+   */
+  public async cleanupFolder(
+    bucketName: string,
+    prefix: string,
+  ): Promise<void> {
+    try {
+      const storageClient = await this.getStorageClient();
+      const bucket = storageClient.bucket(bucketName);
+      const [files] = await bucket.getFiles({ prefix });
+
+      await Promise.all(files.map((file) => file.delete()));
+    } catch (error) {
+      console.error(`Error cleaning up temp files from ${prefix}:`, error);
+    }
+  }
+
+  /**
+   * Parses a GCS URI into bucket and fileName components
+   * @param gcsUri - GCS URI in format gs://bucket/path/to/file
+   * @returns Object with bucket and fileName
+   * @throws Error if URI format is invalid
+   */
+  private parseGcsUri(gcsUri: string): { bucket: string; prefix: string } {
+    const match = gcsUri.match(/^gs:\/\/([^\/]+)\/(.*)$/);
+    if (!match) {
+      throw new Error(`Invalid GCS URI: ${gcsUri}`);
+    }
+    const [, bucket, prefix] = match;
+    if (!bucket || !prefix) {
+      throw new Error(`Invalid GCS URI: ${gcsUri}`);
+    }
+    return { bucket, prefix };
+  }
+}

package/libs/clients/src/hatchet.ts

@@ -0,0 +1,86 @@
+import { Hatchet, type HatchetClient } from "@hatchet-dev/typescript-sdk";
+import type { HatchetConfig } from "@sea/config";
+
+export class HatchetClientMgr {
+  private hatchet: HatchetClient | undefined;
+  private config: HatchetConfig;
+
+  constructor(config: HatchetConfig) {
+    this.config = config;
+  }
+
+  // This is all a bit ugly, but just want to make sure we can easily
+  // test the UX side without actually depending on hosted Hatchet
+  public getHatchet(): HatchetClient {
+    if (this.hatchet) {
+      return this.hatchet;
+    }
+
+    if (this.config.mock && process.env.NODE_ENV !== "production") {
+      console.warn("Hatchet: using MOCK client");
+      this.hatchet = {
+        events: {
+          push: async () => {
+            console.warn("Hatchet push called on mock client");
+          },
+        },
+      } as unknown as ReturnType<typeof Hatchet.init>;
+      return this.hatchet;
+    }
+
+    this.hatchet = Hatchet.init({ token: this.config.clientToken });
+    return this.hatchet;
+  }
+
+  public async pushDoc(
+    documentExtractionId: string,
+    extractionModel: string = "general",
+    userPrompt?: string,
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high",
+  ) {
+    await this.getHatchet().events.push<{
+      documentExtractionId: string;
+      userPrompt?: string;
+      options?: {
+        extractionModel?: string;
+        reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high";
+      };
+    }>("document:uploaded-unified", {
+      documentExtractionId,
+      userPrompt,
+      options: { extractionModel, reasoningEffort },
+    });
+  }
+
+  public async pushDocAgent(
+    documentExtractionId: string,
+    conversationId: string,
+    extractionModel: string = "general",
+    userPrompt?: string,
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high",
+  ) {
+    await this.getHatchet().events.push<{
+      documentExtractionId: string;
+      conversationId: string;
+      userPrompt?: string;
+      options?: {
+        extractionModel?: string;
+        reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high";
+      };
+    }>("document:uploaded-agentic", {
+      documentExtractionId,
+      conversationId,
+      userPrompt,
+      options: { extractionModel, reasoningEffort },
+    });
+  }
+
+  public async pushPptxConversion(documentId: string) {
+    await this.getHatchet().events.push<{ documentId: string }>(
+      "doc:convert-pptx",
+      {
+        documentId,
+      },
+    );
+  }
+}

package/libs/clients/src/index.ts

@@ -0,0 +1,8 @@
+// Client exports
+export * from "./azure.js";
+export * from "./gcp.js";
+export { HatchetClientMgr } from "./hatchet.js";
+export type { HatchetConfig } from "@sea/config";
+export * from "./loops.js";
+export * from "./polar.js";
+export * from "./posthog.js";

package/libs/clients/src/loops.ts

@@ -0,0 +1,86 @@
+import { LoopsClient } from "loops";
+
+export interface LoopsConfig {
+  apiKey: string;
+  baseUrl: string;
+}
+
+/**
+ * Create a Loops email client instance
+ *
+ * @example
+ * ```typescript
+ * import { createLoopsClient } from "@sea/integrations/loops";
+ *
+ * const loops = createLoopsClient({
+ *   apiKey: process.env.LOOPS_API_KEY,
+ *   baseUrl: process.env.BASE_URL,
+ * });
+ * ```
+ */
+export function createLoopsClient(config: LoopsConfig) {
+  const client = new LoopsClient(config.apiKey);
+
+  return {
+    client,
+    /**
+     * Send OTP email for authentication
+     */
+    async sendEmailOtp({
+      email,
+      otp,
+      type,
+    }: {
+      email: string;
+      otp: string;
+      type: "sign-in" | "email-verification" | "forget-password";
+    }) {
+      const resp = await client.sendTransactionalEmail({
+        transactionalId: "cmcn5xl3r27pg2s0jyjnsuuuc",
+        email,
+        dataVariables: {
+          otp,
+          type,
+        },
+      });
+
+      if (!resp.success) {
+        throw new Error("Send email failed");
+      }
+    },
+
+    /**
+     * Send organization invite email
+     */
+    async sendEmailInvite({
+      email,
+      fromName,
+      fromOrg,
+      inviteId,
+    }: {
+      email: string;
+      fromName: string;
+      fromOrg: string;
+      inviteId: string;
+    }) {
+      const url = new URL(`/invite/${inviteId}`, config.baseUrl);
+      const inviteUrl = url.toString();
+
+      const resp = await client.sendTransactionalEmail({
+        transactionalId: "cmcn8xjqu1xcc4b0imsjun3p3",
+        email,
+        dataVariables: {
+          fromName,
+          fromOrg,
+          inviteUrl,
+        },
+      });
+
+      if (!resp.success) {
+        throw new Error("Send email failed");
+      }
+    },
+  };
+}
+
+export type LoopsClientInstance = ReturnType<typeof createLoopsClient>;

package/libs/clients/src/polar.ts

@@ -0,0 +1,77 @@
+import { Polar } from "@polar-sh/sdk";
+import type { MemberHydrated } from "@sea/dal/member";
+import { db, schema } from "@sea/db";
+import { eq } from "drizzle-orm";
+
+export interface PolarConfig {
+  accessToken: string;
+  server: "production" | "sandbox";
+}
+
+/**
+ * Create a Polar billing client instance
+ *
+ * @example
+ * ```typescript
+ * import { createPolarClient } from "@sea/integrations/polar";
+ *
+ * const polar = createPolarClient({
+ *   accessToken: process.env.POLAR_ACCESS_TOKEN,
+ *   server: "production",
+ * });
+ * ```
+ */
+export function createPolarClient(config: PolarConfig) {
+  const client = new Polar({
+    accessToken: config.accessToken,
+    server: config.server,
+  });
+
+  return {
+    client,
+
+    /**
+     * Get or create a customer for the organization
+     */
+    async getCustomer({
+      member,
+    }: {
+      member: MemberHydrated;
+    }): Promise<{ id: string }> {
+      const { customerId } = member.organization;
+      if (customerId) {
+        return { id: customerId };
+      }
+
+      const customer = await fetchOrCreateCustomer(client, { member });
+      await db
+        .update(schema.organization)
+        .set({ customerId: customer.id })
+        .where(eq(schema.organization.id, member.organizationId));
+      return { id: customer.id };
+    },
+  };
+}
+
+async function fetchOrCreateCustomer(
+  client: Polar,
+  { member }: { member: MemberHydrated },
+) {
+  const existingCustomer = await client.customers
+    .getExternal({ externalId: member.user.id })
+    .catch((_) => null);
+  if (existingCustomer) {
+    return existingCustomer;
+  }
+
+  const newCustomer = await client.customers.create({
+    externalId: member.user.id,
+    email: member.user.email,
+  });
+  return newCustomer;
+}
+
+export type PolarClientInstance = ReturnType<typeof createPolarClient>;
+
+// Re-export Polar type for convenience
+export type { Polar };

package/libs/clients/src/posthog.ts

@@ -0,0 +1,55 @@
+import { PostHog } from "posthog-node";
+
+export interface PostHogConfig {
+  key: string;
+  host: string;
+  flushAt?: number;
+  flushInterval?: number;
+}
+
+/**
+ * Create a PostHog client instance
+ *
+ * @example
+ * ```typescript
+ * import { createPostHogClient } from "@sea/clients/posthog";
+ *
+ * const posthog = createPostHogClient({
+ *   key: process.env.POSTHOG_API_KEY,
+ *   host: process.env.POSTHOG_HOST,
+ * });
+ * ```
+ */
+export function createPostHogClient(config: PostHogConfig): PostHog {
+  return new PostHog(config.key, {
+    host: config.host,
+    flushAt: config.flushAt ?? 20,
+    flushInterval: config.flushInterval ?? 10000,
+  });
+}
+
+export type CaptureEventArgs = {
+  event: string;
+  distinctId: string;
+  properties?: Record<string, unknown>;
+  groups?: Record<string, string>;
+};
+
+/**
+ * Capture an event with error handling
+ * Errors are logged but don't throw to avoid breaking core flows
+ */
+export function captureEvent(
+  posthog: PostHog,
+  { event, distinctId, properties, groups }: CaptureEventArgs,
+) {
+  try {
+    posthog.capture({ event, distinctId, properties, groups });
+  } catch (error) {
+    // Avoid surfacing PostHog errors to core flows while still logging for observability
+    console.error("posthog capture failed", error);
+  }
+}
+
+// Re-export PostHog type for convenience
+export type { PostHog };

package/libs/clients/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "moduleResolution": "Bundler",
+    "module": "ESNext",
+    "target": "ES2022",
+    "skipLibCheck": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "noUncheckedIndexedAccess": true,
+    "baseUrl": ".",
+    "outDir": "./dist",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist"]
+}

package/libs/clients/vite.config.ts

@@ -0,0 +1,35 @@
+import { globSync } from "glob";
+import { resolve } from "path";
+import { defineConfig } from "vite";
+import dts from "vite-plugin-dts";
+
+const entries = Object.fromEntries(
+  globSync("src/**/*.ts", { ignore: "src/**/*.d.ts" }).map((file) => [
+    // Remove src/ and .ts extension for the key
+    file.slice(4, -3),
+    resolve(__dirname, file),
+  ]),
+);
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: entries,
+      formats: ["es"],
+    },
+    rollupOptions: {
+      external: (id) => {
+        // Externalize all dependencies (anything from node_modules)
+        return (
+          !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("@/")
+        );
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "src"),
+    },
+  },
+  plugins: [dts()],
+});

package/libs/config/.prettierignore

@@ -0,0 +1,6 @@
+dist
+*.gen.ts
+*.md
+.tanstack
+.nitro
+.output

package/libs/config/.prettierrc.js

@@ -0,0 +1,12 @@
+/* eslint-env node */
+/** @type {import("prettier").Config} */
+const config = {
+  plugins: ["prettier-plugin-organize-imports", "prettier-plugin-tailwindcss"],
+  tailwindFunctions: ["cva", "clsx", "cn"],
+  printWidth: 100,
+  tabWidth: 2,
+  singleQuote: false,
+  quoteProps: "as-needed",
+};
+
+export default config;

package/libs/config/eslint.config.mjs

@@ -0,0 +1,3 @@
+import config from "@sea/lint/eslint";
+
+export default config;

package/libs/config/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@sea/config",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts",
+      "require": "./dist/*.js"
+    }
+  },
+  "scripts": {
+    "build": "vite build",
+    "fmt": "prettier --log-level warn --write .",
+    "lint": "eslint --fix . --ext .js,.jsx,.ts,.tsx",
+    "check": "tsc --noEmit",
+    "test": "echo 'no tests'",
+    "ci:fmt": "prettier --check .",
+    "ci:lint": "eslint . --ext .js,.jsx,.ts,.tsx",
+    "ci:check": "pnpm run check",
+    "ci:test": "pnpm run test",
+    "all": "pnpm run fmt && pnpm run lint && pnpm run check && pnpm run test"
+  },
+  "dependencies": {
+    "date-fns": "^4.1.0",
+    "nanoid": "^5.1.5"
+  },
+  "devDependencies": {
+    "@sea/lint": "workspace:*",
+    "@types/pg": "^8.11.11",
+    "drizzle-kit": "^0.30.5",
+    "glob": "^11.0.3",
+    "vite": "^7.1.2",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.0.8"
+  },
+  "engines": {
+    "node": ">=22.0.0 <23.0.0",
+    "pnpm": ">=10.13.0 <11.0.0"
+  },
+  "overrides": {}
+}