v0.6.2: mothership stability, chat iframe embedding, KB upserts, new blog post

Author: waleedlatif1

apps/sim/app/(home)/components/enterprise/enterprise.tsx

@@ -22,9 +22,10 @@ const PRICING_TIERS: PricingTier[] = [
     features: [
       '1,000 credits (trial)',
       '5GB file storage',
+      '3 tables · 1,000 rows each',
       '5 min execution limit',
-      'Limited log retention',
-      'CLI/SDK Access',
+      '7-day log retention',
+      'CLI/SDK/MCP Access',
     ],
     cta: { label: 'Get started', href: '/signup' },
   },
@@ -36,11 +37,12 @@ const PRICING_TIERS: PricingTier[] = [
     billingPeriod: 'per month',
     color: '#00F701',
     features: [
-      '6,000 credits/mo',
-      '+50 daily refresh credits',
-      '150 runs/min (sync)',
-      '50 min sync execution limit',
+      '6,000 credits/mo · +50/day',
       '50GB file storage',
+      '25 tables · 5,000 rows each',
+      '50 min execution · 150 runs/min',
+      'Unlimited log retention',
+      'CLI/SDK/MCP Access',
     ],
     cta: { label: 'Get started', href: '/signup' },
   },
@@ -52,11 +54,12 @@ const PRICING_TIERS: PricingTier[] = [
     billingPeriod: 'per month',
     color: '#FA4EDF',
     features: [
-      '25,000 credits/mo',
-      '+200 daily refresh credits',
-      '300 runs/min (sync)',
-      '50 min sync execution limit',
+      '25,000 credits/mo · +200/day',
       '500GB file storage',
+      '25 tables · 5,000 rows each',
+      '50 min execution · 300 runs/min',
+      'Unlimited log retention',
+      'CLI/SDK/MCP Access',
     ],
     cta: { label: 'Get started', href: '/signup' },
   },
@@ -66,7 +69,15 @@ const PRICING_TIERS: PricingTier[] = [
     description: 'For organizations needing security and scale',
     price: 'Custom',
     color: '#FFCC02',
-    features: ['Custom infra limits', 'SSO', 'SOC2', 'Self hosting', 'Dedicated support'],
+    features: [
+      'Custom credits & infra limits',
+      'Custom file storage',
+      '10,000 tables · 1M rows each',
+      'Custom execution limits',
+      'Unlimited log retention',
+      'SSO & SCIM · SOC2 & HIPAA',
+      'Self hosting · Dedicated support',
+    ],
     cta: { label: 'Book a demo', href: '/contact' },
   },
 ]
@@ -114,12 +125,12 @@ function PricingCard({ tier }: PricingCardProps) {
           </p>
           <div className='mt-4'>
             {isEnterprise ? (
-              <a
+              <Link
                 href={tier.cta.href}
                 className='flex h-[32px] w-full items-center justify-center rounded-[5px] border border-[#E5E5E5] px-[10px] font-[430] font-season text-[#1C1C1C] text-[14px] transition-colors hover:bg-[#F0F0F0]'
               >
                 {tier.cta.label}
-              </a>
+              </Link>
             ) : isPro ? (
               <Link
                 href={tier.cta.href}

apps/sim/app/(home)/components/features/components/features-preview.tsx

@@ -28,8 +28,8 @@ import {
  *   for immediate availability to AI crawlers.
  * - Section `id` attributes serve as fragment anchors for precise AI citations.
  * - Content ordering prioritizes answer-first patterns: definition (Hero) ->
- *   examples (Templates) -> capabilities (Features) -> social proof (Collaboration, Testimonials) ->
- *   pricing (Pricing) -> enterprise (Enterprise).
+ *   examples (Templates) -> capabilities (Features) -> social proof (Collaboration) ->
+ *   enterprise (Enterprise) -> pricing (Pricing) -> testimonials (Testimonials).
  */
 export default async function Landing() {
   return (
@@ -43,8 +43,8 @@ export default async function Landing() {
         <Templates />
         <Features />
         <Collaboration />
-        <Pricing />
         <Enterprise />
+        <Pricing />
         <Testimonials />
       </main>
       <Footer />

apps/sim/app/(home)/components/pricing/pricing.tsx

@@ -0,0 +1,248 @@
+import { randomUUID } from 'crypto'
+import { db } from '@sim/db'
+import { document } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, isNull } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import {
+  createDocumentRecords,
+  deleteDocument,
+  getProcessingConfig,
+  processDocumentsWithQueue,
+} from '@/lib/knowledge/documents/service'
+import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
+import { checkKnowledgeBaseWriteAccess } from '@/app/api/knowledge/utils'
+
+const logger = createLogger('DocumentUpsertAPI')
+
+const UpsertDocumentSchema = z.object({
+  documentId: z.string().optional(),
+  filename: z.string().min(1, 'Filename is required'),
+  fileUrl: z.string().min(1, 'File URL is required'),
+  fileSize: z.number().min(1, 'File size must be greater than 0'),
+  mimeType: z.string().min(1, 'MIME type is required'),
+  documentTagsData: z.string().optional(),
+  processingOptions: z.object({
+    chunkSize: z.number().min(100).max(4000),
+    minCharactersPerChunk: z.number().min(1).max(2000),
+    recipe: z.string(),
+    lang: z.string(),
+    chunkOverlap: z.number().min(0).max(500),
+  }),
+  workflowId: z.string().optional(),
+})
+
+export async function POST(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const requestId = randomUUID().slice(0, 8)
+  const { id: knowledgeBaseId } = await params
+
+  try {
+    const body = await req.json()
+
+    logger.info(`[${requestId}] Knowledge base document upsert request`, {
+      knowledgeBaseId,
+      hasDocumentId: !!body.documentId,
+      filename: body.filename,
+    })
+
+    const auth = await checkSessionOrInternalAuth(req, { requireWorkflowId: false })
+    if (!auth.success || !auth.userId) {
+      logger.warn(`[${requestId}] Authentication failed: ${auth.error || 'Unauthorized'}`)
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+    const userId = auth.userId
+
+    const validatedData = UpsertDocumentSchema.parse(body)
+
+    if (validatedData.workflowId) {
+      const authorization = await authorizeWorkflowByWorkspacePermission({
+        workflowId: validatedData.workflowId,
+        userId,
+        action: 'write',
+      })
+      if (!authorization.allowed) {
+        return NextResponse.json(
+          { error: authorization.message || 'Access denied' },
+          { status: authorization.status }
+        )
+      }
+    }
+
+    const accessCheck = await checkKnowledgeBaseWriteAccess(knowledgeBaseId, userId)
+
+    if (!accessCheck.hasAccess) {
+      if ('notFound' in accessCheck && accessCheck.notFound) {
+        logger.warn(`[${requestId}] Knowledge base not found: ${knowledgeBaseId}`)
+        return NextResponse.json({ error: 'Knowledge base not found' }, { status: 404 })
+      }
+      logger.warn(
+        `[${requestId}] User ${userId} attempted to upsert document in unauthorized knowledge base ${knowledgeBaseId}`
+      )
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    let existingDocumentId: string | null = null
+    let isUpdate = false
+
+    if (validatedData.documentId) {
+      const existingDoc = await db
+        .select({ id: document.id })
+        .from(document)
+        .where(
+          and(
+            eq(document.id, validatedData.documentId),
+            eq(document.knowledgeBaseId, knowledgeBaseId),
+            isNull(document.deletedAt)
+          )
+        )
+        .limit(1)
+
+      if (existingDoc.length > 0) {
+        existingDocumentId = existingDoc[0].id
+      }
+    } else {
+      const docsByFilename = await db
+        .select({ id: document.id })
+        .from(document)
+        .where(
+          and(
+            eq(document.filename, validatedData.filename),
+            eq(document.knowledgeBaseId, knowledgeBaseId),
+            isNull(document.deletedAt)
+          )
+        )
+        .limit(1)
+
+      if (docsByFilename.length > 0) {
+        existingDocumentId = docsByFilename[0].id
+      }
+    }
+
+    if (existingDocumentId) {
+      isUpdate = true
+      logger.info(
+        `[${requestId}] Found existing document ${existingDocumentId}, creating replacement before deleting old`
+      )
+    }
+
+    const createdDocuments = await createDocumentRecords(
+      [
+        {
+          filename: validatedData.filename,
+          fileUrl: validatedData.fileUrl,
+          fileSize: validatedData.fileSize,
+          mimeType: validatedData.mimeType,
+          ...(validatedData.documentTagsData && {
+            documentTagsData: validatedData.documentTagsData,
+          }),
+        },
+      ],
+      knowledgeBaseId,
+      requestId
+    )
+
+    const firstDocument = createdDocuments[0]
+    if (!firstDocument) {
+      logger.error(`[${requestId}] createDocumentRecords returned empty array unexpectedly`)
+      return NextResponse.json({ error: 'Failed to create document record' }, { status: 500 })
+    }
+
+    if (existingDocumentId) {
+      try {
+        await deleteDocument(existingDocumentId, requestId)
+      } catch (deleteError) {
+        logger.error(
+          `[${requestId}] Failed to delete old document ${existingDocumentId}, rolling back new record`,
+          deleteError
+        )
+        await deleteDocument(firstDocument.documentId, requestId).catch(() => {})
+        return NextResponse.json({ error: 'Failed to replace existing document' }, { status: 500 })
+      }
+    }
+
+    processDocumentsWithQueue(
+      createdDocuments,
+      knowledgeBaseId,
+      validatedData.processingOptions,
+      requestId
+    ).catch((error: unknown) => {
+      logger.error(`[${requestId}] Critical error in document processing pipeline:`, error)
+    })
+
+    try {
+      const { PlatformEvents } = await import('@/lib/core/telemetry')
+      PlatformEvents.knowledgeBaseDocumentsUploaded({
+        knowledgeBaseId,
+        documentsCount: 1,
+        uploadType: 'single',
+        chunkSize: validatedData.processingOptions.chunkSize,
+        recipe: validatedData.processingOptions.recipe,
+      })
+    } catch (_e) {
+      // Silently fail
+    }
+
+    recordAudit({
+      workspaceId: accessCheck.knowledgeBase?.workspaceId ?? null,
+      actorId: userId,
+      actorName: auth.userName,
+      actorEmail: auth.userEmail,
+      action: isUpdate ? AuditAction.DOCUMENT_UPDATED : AuditAction.DOCUMENT_UPLOADED,
+      resourceType: AuditResourceType.DOCUMENT,
+      resourceId: knowledgeBaseId,
+      resourceName: validatedData.filename,
+      description: isUpdate
+        ? `Upserted (replaced) document "${validatedData.filename}" in knowledge base "${knowledgeBaseId}"`
+        : `Upserted (created) document "${validatedData.filename}" in knowledge base "${knowledgeBaseId}"`,
+      metadata: {
+        fileName: validatedData.filename,
+        previousDocumentId: existingDocumentId,
+        isUpdate,
+      },
+      request: req,
+    })
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        documentsCreated: [
+          {
+            documentId: firstDocument.documentId,
+            filename: firstDocument.filename,
+            status: 'pending',
+          },
+        ],
+        isUpdate,
+        previousDocumentId: existingDocumentId,
+        processingMethod: 'background',
+        processingConfig: {
+          maxConcurrentDocuments: getProcessingConfig().maxConcurrentDocuments,
+          batchSize: getProcessingConfig().batchSize,
+        },
+      },
+    })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      logger.warn(`[${requestId}] Invalid upsert request data`, { errors: error.errors })
+      return NextResponse.json(
+        { error: 'Invalid request data', details: error.errors },
+        { status: 400 }
+      )
+    }
+
+    logger.error(`[${requestId}] Error upserting document`, error)
+
+    const errorMessage = error instanceof Error ? error.message : 'Failed to upsert document'
+    const isStorageLimitError =
+      errorMessage.includes('Storage limit exceeded') || errorMessage.includes('storage limit')
+    const isMissingKnowledgeBase = errorMessage === 'Knowledge base not found'
+
+    return NextResponse.json(
+      { error: errorMessage },
+      { status: isMissingKnowledgeBase ? 404 : isStorageLimitError ? 413 : 500 }
+    )
+  }
+}

apps/sim/app/(home)/landing.tsx

@@ -279,6 +279,7 @@ export async function POST(req: NextRequest) {
             role: 'assistant' as const,
             content: result.content,
             timestamp: new Date().toISOString(),
+            ...(result.requestId ? { requestId: result.requestId } : {}),
           }
           if (result.toolCalls.length > 0) {
             assistantMessage.toolCalls = result.toolCalls

apps/sim/app/api/knowledge/[id]/documents/upsert/route.ts

@@ -1,5 +1,6 @@
 export { ErrorState, type ErrorStateProps } from './error'
 export { InlineRenameInput } from './inline-rename-input'
+export { MessageActions } from './message-actions'
 export { ownerCell } from './resource/components/owner-cell/owner-cell'
 export type {
   BreadcrumbEditing,

apps/sim/app/api/mothership/chat/route.ts

@@ -0,0 +1 @@
+export { MessageActions } from './message-actions'