sea-dev 1.0.0

package/apps/main/src/routes/_authed/_app/pipelines/-fns.ts

@@ -0,0 +1,510 @@
+import { getAppConfig } from "@/lib/config";
+import { membershipMiddleware } from "@/middleware";
+import { createLanguageModel } from "@sea/ai/models";
+import {
+  addStepDependency,
+  createEmptyPipeline,
+  createPipelineStep,
+  deletePipeline,
+  deletePipelineStep,
+  getAllBlockersForRun,
+  getPipelineData,
+  getPipelines,
+  removeStepDependency,
+  replayPipelineRun,
+  replayPipelineRunStep,
+  syncRunBlockers,
+  updatePipeline,
+  updatePipelineStep,
+} from "@sea/core";
+import { getExtractionSetup } from "@sea/core/data-extraction/utils";
+import {
+  createPipelineRun,
+  linkDocumentsToRunStep,
+  linkManualInputsToRunStep,
+  resolveBlocker,
+  retryRunStep,
+} from "@sea/dal/pipeline";
+import { db, schema } from "@sea/db";
+import { nanoid } from "@sea/util/id";
+import { notFound } from "@tanstack/react-router";
+import { createServerFn } from "@tanstack/react-start";
+import { and, eq } from "drizzle-orm";
+
+const config = getAppConfig();
+const model = createLanguageModel({
+  gatewayApiKey: config.vercel.aiGatewayApiKey,
+  modelId: "openai/gpt-5.2",
+});
+
+export const getPipelinesFn = createServerFn({ method: "GET" })
+  .middleware([membershipMiddleware])
+  .handler(async ({ context: { member } }) => {
+    const result = await getPipelines({ member });
+    if (!result.ok) throw notFound();
+    return { pipelines: result.data };
+  });
+
+export const getPipelineDataFn = createServerFn({ method: "GET" })
+  .middleware([membershipMiddleware])
+  .validator((data: { pipelineId: string }) => data)
+  .handler(async ({ context: { member }, data: { pipelineId } }) => {
+    const result = await getPipelineData({ member, pipelineId });
+    if (!result.ok) throw notFound();
+    return result.data!;
+  });
+
+export const deletePipelineFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { pipelineId: string }) => data)
+  .handler(async ({ context: { member }, data: { pipelineId } }) => {
+    const result = await deletePipeline({ member, pipelineId });
+    if (!result.ok) throw notFound();
+    return result.data;
+  });
+
+export const createEmptyPipelineFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .handler(async ({ context: { member } }) => {
+    const result = await createEmptyPipeline({ member });
+    if (!result.ok) throw new Error("Operation failed");
+    return result.data;
+  });
+
+export const createPipelineRunFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: {
+      pipelineId: string;
+      dealId: string;
+      documentIds?: string[];
+      submissionIds?: string[];
+    }) => data,
+  )
+  .handler(async ({ context: { member }, data: { pipelineId, dealId } }) => {
+    const result = await createPipelineRun({
+      member,
+      pipelineId,
+      dealId,
+      triggerType: "manual",
+    });
+    if (!result.ok) {
+      if (result.error === "not-found") throw notFound();
+      throw new Error("Operation failed");
+    }
+
+    // Sync blockers after creating the run
+    await syncRunBlockers({ member, runId: result.data.id });
+
+    return { runId: result.data.id };
+  });
+
+export const startPipelineRunFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { runId: string; pipelineId: string }) => data)
+  .handler(async ({ context: { member }, data: { runId, pipelineId } }) => {
+    const { HatchetClientMgr } = await import("@sea/clients/hatchet");
+    const hatchet = new HatchetClientMgr(config.hatchet);
+
+    // Trigger the pipeline:run event which starts the DAG workflow
+    await hatchet.getHatchet().events.push("pipeline:run", {
+      runId,
+      pipelineId,
+      memberId: member.id,
+    });
+
+    return { runId };
+  });
+
+export const updatePipelineFn = createServerFn()
+  .middleware([membershipMiddleware])
+  .validator((data: { pipelineId: string; name: string; description: string }) => data)
+  .handler(async ({ context: { member }, data: { pipelineId, name, description } }) => {
+    const result = await updatePipeline({
+      member,
+      pipelineId,
+      name,
+      description,
+    });
+    if (!result.ok) throw notFound();
+    return result.data;
+  });
+
+export const replayPipelineRunFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { runId: string }) => data)
+  .handler(async ({ context: { member }, data: { runId } }) => {
+    const result = await replayPipelineRun({
+      member,
+      runId,
+      config: { model },
+    });
+    if (!result.ok) {
+      if (result.error === "not-found") throw notFound();
+      throw new Error(result.error);
+    }
+    return result.data;
+  });
+
+export const replayPipelineRunStepFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { runStepId: string }) => data)
+  .handler(async ({ context: { member }, data: { runStepId } }) => {
+    const result = await replayPipelineRunStep({
+      member,
+      runStepId,
+      config: { model },
+    });
+    if (!result.ok) {
+      if (result.error === "not-found") throw notFound();
+      throw new Error(result.error);
+    }
+    return result.data;
+  });
+
+export const addStepDependencyFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: { childStepId: string; parentStepId: string; multiFormGroupId?: string | null }) => data,
+  )
+  .handler(
+    async ({ context: { member }, data: { childStepId, parentStepId, multiFormGroupId } }) => {
+      const result = await addStepDependency({
+        member,
+        childStepId,
+        parentStepId,
+        multiFormGroupId,
+      });
+      if (!result.ok) {
+        if (result.error === "not-found") throw notFound();
+        throw new Error("Failed to add dependency");
+      }
+      return result.data;
+    },
+  );
+
+export const removeStepDependencyFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { dependencyId: string }) => data)
+  .handler(async ({ context: { member }, data: { dependencyId } }) => {
+    const result = await removeStepDependency({ member, dependencyId });
+    if (!result.ok) {
+      if (result.error === "not-found") throw notFound();
+      throw new Error("Failed to remove dependency");
+    }
+    return result.data;
+  });
+
+// Step CRUD Operations
+export const createStepFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: {
+      pipelineId: string;
+      name: string;
+      description: string;
+      prompt?: string;
+      type: "single" | "multi";
+      role: "extraction" | "integration" | "analysis" | null;
+      outputFormIds?: string[];
+      toolsAllowed?: string[];
+      integrationConfig?: {
+        method: "GET" | "POST" | "PUT" | "DELETE";
+        urlTemplate: string;
+        headers: Record<string, string>;
+        bodyTemplate?: string;
+      };
+    }) => data,
+  )
+  .handler(async ({ context: { member }, data }) => {
+    const result = await createPipelineStep({ member, ...data });
+    if (!result.ok) {
+      if (result.error === "not-found") throw notFound();
+      throw new Error("Failed to create step");
+    }
+    return result.data;
+  });
+
+export const updateStepFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: {
+      stepId: string;
+      name?: string;
+      description?: string;
+      prompt?: string;
+      type?: "single" | "multi";
+      role?: "extraction" | "integration" | "analysis" | null;
+      outputFormIds?: string[];
+      toolsAllowed?: string[];
+      integrationConfig?: {
+        method: "GET" | "POST" | "PUT" | "DELETE";
+        urlTemplate: string;
+        headers: Record<string, string>;
+        bodyTemplate?: string;
+      } | null;
+    }) => data,
+  )
+  .handler(async ({ context: { member }, data }) => {
+    const result = await updatePipelineStep({ member, ...data });
+    if (!result.ok) {
+      if (result.error === "not-found") throw notFound();
+      throw new Error("Failed to update step");
+    }
+    return result.data;
+  });
+
+export const deleteStepFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { stepId: string }) => data)
+  .handler(async ({ context: { member }, data: { stepId } }) => {
+    const result = await deletePipelineStep({ member, stepId });
+    if (!result.ok) {
+      if (result.error === "not-found") throw notFound();
+      throw new Error("Failed to delete step");
+    }
+    return result.data;
+  });
+
+// Blockers
+export const getRunBlockersFn = createServerFn({ method: "GET" })
+  .middleware([membershipMiddleware])
+  .validator((data: { runId: string }) => data)
+  .handler(async ({ context: { member }, data: { runId } }) => {
+    const result = await getAllBlockersForRun({ member, runId });
+    if (!result.ok) {
+      if (result.error === "not-found") throw notFound();
+      throw new Error("Failed to get blockers");
+    }
+    return result.data;
+  });
+
+export const syncRunBlockersFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { runId: string }) => data)
+  .handler(async ({ context: { member }, data: { runId } }) => {
+    const result = await syncRunBlockers({ member, runId });
+    if (!result.ok) {
+      if (result.error === "not-found") {
+        throw notFound();
+      }
+      throw new Error("Failed to sync blockers");
+    }
+    return result.data;
+  });
+
+export const linkDocumentsToRunStepFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { runStepId: string; documentIds: string[] }) => data)
+  .handler(async ({ context: { member }, data: { runStepId, documentIds } }) => {
+    const result = await linkDocumentsToRunStep({ member, runStepId, documentIds });
+    if (!result.ok) {
+      if (result.error === "not-found") {
+        throw notFound();
+      }
+      throw new Error("Failed to link documents");
+    }
+    return result.data;
+  });
+
+// Pipeline-specific document insertion (documents without extraction/submission)
+// Pipeline documents are just uploaded files linked to run steps
+export const insertPipelineDocumentFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { runId: string; files: { id: string; name: string; type: string }[] }) => data)
+  .handler(async ({ context: { member }, data: { runId, files } }) => {
+    console.log("[insertPipelineDocumentFn] Starting", {
+      runId,
+      memberId: member.id,
+      orgId: member.organizationId,
+      fileCount: files.length,
+    });
+
+    // Get the run to verify ownership and get dealId
+    const run = await db.query.pipelineRun.findFirst({
+      where: and(
+        eq(schema.pipelineRun.id, runId),
+        eq(schema.pipelineRun.organizationId, member.organizationId),
+      ),
+    });
+
+    if (!run) {
+      throw notFound();
+    }
+
+    // Get storage config (always GCP for now)
+    const { storageProvider, displayType } = getExtractionSetup(config);
+
+    // HACK: Set classification flag for specific pipeline
+    const composite = run.pipelineId === "y8cxngcs5ro8d8efev5r8";
+    const documents = await Promise.all(
+      files.map(async (file) => {
+        const { name, type: contentType, id } = file;
+        const blobKey = nanoid() + "-" + name;
+
+        // Just insert document - no extraction needed for pipeline docs
+        const [insertedDocument] = await db
+          .insert(schema.document)
+          .values({
+            id,
+            dealId: run.dealId,
+            name,
+            contentType,
+            storageProvider,
+            displayType,
+            blobKey,
+            composite,
+          })
+          .returning();
+
+        if (!insertedDocument) throw new Error("Failed to create document");
+
+        return {
+          documentId: insertedDocument.id,
+          blobKey,
+        };
+      }),
+    );
+
+    return documents;
+  });
+
+// Upload pipeline document (server-side upload to avoid CORS issues)
+export const uploadPipelineDocumentFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((formData: FormData) => {
+    const documentId = formData.get("documentId");
+    const file = formData.get("file");
+    if (typeof documentId !== "string") throw new Error("Invalid documentId");
+    if (!(file instanceof File)) throw new Error("Invalid file");
+    return { documentId, file };
+  })
+  .handler(async ({ context: { member }, data: { documentId, file } }) => {
+    // Get document and verify ownership
+    const document = await db.query.document.findFirst({
+      where: eq(schema.document.id, documentId),
+      with: {
+        deal: {
+          columns: { organizationId: true },
+        },
+      },
+    });
+
+    if (!document) {
+      throw notFound();
+    }
+    if (document.deal.organizationId !== member.organizationId) {
+      console.error("[uploadPipelineDocumentFn] Org mismatch", {
+        documentOrg: document.deal.organizationId,
+        memberOrg: member.organizationId,
+      });
+      throw notFound();
+    }
+
+    const { blobKey } = document;
+    const { client: storageClient } = getExtractionSetup(config);
+
+    // Upload file to storage
+    const buffer = Buffer.from(await file.arrayBuffer());
+    await storageClient.uploadFile(buffer, blobKey, file.type);
+
+    // Get signed URL for viewing
+    const { url, expiry } = await storageClient.getSignedUrl(blobKey);
+
+    // Update document with upload info
+    await db
+      .update(schema.document)
+      .set({ uploaded: true, blobUrl: url, blobUrlExpiry: expiry })
+      .where(eq(schema.document.id, documentId));
+
+    return { documentId, uploaded: true };
+  });
+
+// Blocker Resolution
+export const resolveBlockerWithUploadFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { blockerId: string; runStepId: string; documentIds: string[] }) => data)
+  .handler(async ({ context: { member }, data: { blockerId, runStepId, documentIds } }) => {
+    // Link documents to the run step
+    const linkResult = await linkDocumentsToRunStep({ member, runStepId, documentIds });
+    if (!linkResult.ok) {
+      if (linkResult.error === "not-found") throw notFound();
+      throw new Error("Failed to link documents");
+    }
+
+    // Mark blocker as resolved
+    const resolveResult = await resolveBlocker(blockerId);
+    if (!resolveResult.ok) {
+      if (resolveResult.error === "not-found") throw notFound();
+      throw new Error("Failed to resolve blocker");
+    }
+
+    // Retry the step
+    const retryResult = await retryRunStep({ member, runStepId });
+    if (!retryResult.ok) {
+      if (retryResult.error === "not-found") throw notFound();
+      throw new Error("Failed to retry step");
+    }
+
+    return { success: true };
+  });
+
+export const resolveBlockerWithManualInputFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator(
+    (data: { blockerId: string; runStepId: string; submissionIds: string[]; reason?: string }) =>
+      data,
+  )
+  .handler(
+    async ({ context: { member }, data: { blockerId, runStepId, submissionIds, reason } }) => {
+      // Link submissions to the run step
+      const linkResult = await linkManualInputsToRunStep({
+        member,
+        runStepId,
+        submissionIds,
+        addedBy: member.id,
+        reason,
+      });
+      if (!linkResult.ok) {
+        if (linkResult.error === "not-found") throw notFound();
+        throw new Error("Failed to link submissions");
+      }
+
+      // Mark blocker as resolved
+      const resolveResult = await resolveBlocker(blockerId);
+      if (!resolveResult.ok) {
+        if (resolveResult.error === "not-found") throw notFound();
+        throw new Error("Failed to resolve blocker");
+      }
+
+      // Retry the step
+      const retryResult = await retryRunStep({ member, runStepId });
+      if (!retryResult.ok) {
+        if (retryResult.error === "not-found") throw notFound();
+        throw new Error("Failed to retry step");
+      }
+
+      return { success: true };
+    },
+  );
+
+export const resolveBlockerWithConfigFixFn = createServerFn({ method: "POST" })
+  .middleware([membershipMiddleware])
+  .validator((data: { blockerId: string; runStepId: string }) => data)
+  .handler(async ({ context: { member }, data: { blockerId, runStepId } }) => {
+    // Mark blocker as resolved (config is already fixed by user)
+    const resolveResult = await resolveBlocker(blockerId);
+    if (!resolveResult.ok) {
+      if (resolveResult.error === "not-found") throw notFound();
+      throw new Error("Failed to resolve blocker");
+    }
+
+    // Retry the step
+    const retryResult = await retryRunStep({ member, runStepId });
+    if (!retryResult.ok) {
+      if (retryResult.error === "not-found") throw notFound();
+      throw new Error("Failed to retry step");
+    }
+
+    return { success: true };
+  });

package/apps/main/src/routes/_authed/_app/pipelines/index.tsx

@@ -0,0 +1,103 @@
+import { Grid } from "@/components/grid";
+import { Container } from "@/components/header/container";
+import { RelDate } from "@sea/ui/components/misc/rel-date";
+import { Alert, AlertDescription, AlertTitle } from "@sea/ui/components/ui/alert";
+import { Badge } from "@sea/ui/components/ui/badge";
+import { Button } from "@sea/ui/components/ui/button";
+import { H1, H2 } from "@sea/ui/components/ui/typography";
+import { Link, createFileRoute, useRouter } from "@tanstack/react-router";
+import { useServerFn } from "@tanstack/react-start";
+import { InfoIcon, PlusIcon } from "lucide-react";
+import { useState } from "react";
+import { createEmptyPipelineFn, getPipelinesFn } from "./-fns";
+
+export const Route = createFileRoute("/_authed/_app/pipelines/")({
+  loader: () => getPipelinesFn(),
+  component: RouteComponent,
+});
+
+const CRUMBS = [{ href: "/pipelines", label: "Pipelines" }];
+
+function RouteComponent() {
+  const { pipelines } = Route.useLoaderData();
+  const router = useRouter();
+  const createPipeline = useServerFn(createEmptyPipelineFn);
+  const [isCreating, setIsCreating] = useState(false);
+
+  const handleCreatePipeline = async () => {
+    setIsCreating(true);
+    try {
+      const result = await createPipeline();
+      if (!result?.id) throw new Error("Failed to create pipeline");
+      void router.navigate({ to: "/pipelines/$pipelineId", params: { pipelineId: result.id } });
+    } catch (error) {
+      console.error("Failed to create pipeline:", error);
+      setIsCreating(false);
+    }
+  };
+
+  return (
+    <Container crumbs={CRUMBS}>
+      <div className="flex items-center justify-between">
+        <H1>Pipelines</H1>
+        <div className="flex items-center gap-2">
+          <Button variant="outline" asChild>
+            <Link to="/feedback">Feedback</Link>
+          </Button>
+          <Button onClick={handleCreatePipeline} disabled={isCreating}>
+            <PlusIcon className="mr-2 size-4" />
+            {isCreating ? "Creating..." : "Create Pipeline"}
+          </Button>
+        </div>
+      </div>
+
+      {pipelines.length === 0 ? (
+        <Alert variant="primary">
+          <InfoIcon className="size-4" />
+          <AlertTitle>No pipelines found</AlertTitle>
+          <AlertDescription>
+            <p className="mb-2">
+              Pipelines define multi-step agent workflows that transform data from one form to
+              another.
+            </p>
+            <Button
+              variant="outline"
+              extra="action"
+              onClick={handleCreatePipeline}
+              disabled={isCreating}
+            >
+              <PlusIcon className="mr-2 size-4" />
+              {isCreating ? "Creating..." : "Create your first pipeline"}
+            </Button>
+          </AlertDescription>
+        </Alert>
+      ) : (
+        <Grid>
+          {pipelines.map((pipeline) => (
+            <Link
+              key={pipeline.id}
+              to="/pipelines/$pipelineId"
+              params={{ pipelineId: pipeline.id }}
+              className="hover:bg-muted/50 flex flex-col gap-2 rounded-lg border p-4 transition-colors"
+            >
+              <H2>{pipeline.name}</H2>
+              <p className="text-muted-foreground text-sm">{pipeline.description}</p>
+              <div className="flex flex-wrap items-center gap-2">
+                <Badge variant="brandsec">
+                  {pipeline.steps.length} step
+                  {pipeline.steps.length === 1 ? "" : "s"}
+                </Badge>
+                <Badge variant={pipeline.isActive ? "green" : "secondary"}>
+                  {pipeline.isActive ? "Active" : "Inactive"}
+                </Badge>
+              </div>
+              <p className="text-muted-foreground mt-1 text-xs">
+                Updated <RelDate date={pipeline.updatedAt} />
+              </p>
+            </Link>
+          ))}
+        </Grid>
+      )}
+    </Container>
+  );
+}