improvement(copilot): v0.2

apps/sim/app/api/chat/manage/[id]/route.test.ts

@@ -19,6 +19,7 @@ describe('Chat Edit API Route', () => {
   const mockCreateErrorResponse = vi.fn()
   const mockEncryptSecret = vi.fn()
   const mockCheckChatAccess = vi.fn()
+  const mockGetSession = vi.fn()
 
   beforeEach(() => {
     vi.resetModules()
@@ -42,6 +43,10 @@ describe('Chat Edit API Route', () => {
       chat: { id: 'id', identifier: 'identifier', userId: 'userId' },
     }))
 
+    vi.doMock('@/lib/auth', () => ({
+      getSession: mockGetSession,
+    }))
+
     vi.doMock('@/lib/logs/console/logger', () => ({
       createLogger: vi.fn().mockReturnValue({
         info: vi.fn(),
@@ -89,9 +94,7 @@ describe('Chat Edit API Route', () => {
 
   describe('GET', () => {
     it('should return 401 when user is not authenticated', async () => {
-      vi.doMock('@/lib/auth', () => ({
-        getSession: vi.fn().mockResolvedValue(null),
-      }))
+      mockGetSession.mockResolvedValueOnce(null)
 
       const req = new NextRequest('http://localhost:3000/api/chat/manage/chat-123')
       const { GET } = await import('@/app/api/chat/manage/[id]/route')
@@ -102,11 +105,9 @@ describe('Chat Edit API Route', () => {
     })
 
     it('should return 404 when chat not found or access denied', async () => {
-      vi.doMock('@/lib/auth', () => ({
-        getSession: vi.fn().mockResolvedValue({
-          user: { id: 'user-id' },
-        }),
-      }))
+      mockGetSession.mockResolvedValueOnce({
+        user: { id: 'user-id' },
+      })
 
       mockCheckChatAccess.mockResolvedValue({ hasAccess: false })
 

apps/sim/app/api/copilot/chat/route.test.ts

@@ -563,6 +563,8 @@ describe('Copilot Chat API Route', () => {
             ],
             messageCount: 4,
             previewYaml: null,
+            config: null,
+            planArtifact: null,
             createdAt: '2024-01-01T00:00:00.000Z',
             updatedAt: '2024-01-02T00:00:00.000Z',
           },
@@ -576,6 +578,8 @@ describe('Copilot Chat API Route', () => {
             ],
             messageCount: 2,
             previewYaml: null,
+            config: null,
+            planArtifact: null,
             createdAt: '2024-01-03T00:00:00.000Z',
             updatedAt: '2024-01-04T00:00:00.000Z',
           },

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

@@ -53,7 +53,7 @@ const ChatMessageSchema = z.object({
     ])
     .optional()
     .default('claude-4.5-sonnet'),
-  mode: z.enum(['ask', 'agent']).optional().default('agent'),
+  mode: z.enum(['ask', 'agent', 'plan']).optional().default('agent'),
   prefetch: z.boolean().optional(),
   createNewChat: z.boolean().optional().default(false),
   stream: z.boolean().optional().default(true),
@@ -880,6 +880,8 @@ export async function GET(req: NextRequest) {
         title: copilotChats.title,
         model: copilotChats.model,
         messages: copilotChats.messages,
+        planArtifact: copilotChats.planArtifact,
+        config: copilotChats.config,
         createdAt: copilotChats.createdAt,
         updatedAt: copilotChats.updatedAt,
       })
@@ -897,6 +899,8 @@ export async function GET(req: NextRequest) {
       messages: Array.isArray(chat.messages) ? chat.messages : [],
       messageCount: Array.isArray(chat.messages) ? chat.messages.length : 0,
       previewYaml: null, // Not needed for chat list
+      planArtifact: chat.planArtifact || null,
+      config: chat.config || null,
       createdAt: chat.createdAt,
       updatedAt: chat.updatedAt,
     }))

apps/sim/app/api/copilot/chat/update-messages/route.ts

@@ -37,6 +37,14 @@ const UpdateMessagesSchema = z.object({
         .optional(),
     })
   ),
+  planArtifact: z.string().nullable().optional(),
+  config: z
+    .object({
+      mode: z.enum(['ask', 'build', 'plan']).optional(),
+      model: z.string().optional(),
+    })
+    .nullable()
+    .optional(),
 })
 
 export async function POST(req: NextRequest) {
@@ -49,7 +57,7 @@ export async function POST(req: NextRequest) {
     }
 
     const body = await req.json()
-    const { chatId, messages } = UpdateMessagesSchema.parse(body)
+    const { chatId, messages, planArtifact, config } = UpdateMessagesSchema.parse(body)
 
     // Verify that the chat belongs to the user
     const [chat] = await db
@@ -62,18 +70,27 @@ export async function POST(req: NextRequest) {
       return createNotFoundResponse('Chat not found or unauthorized')
     }
 
-    // Update chat with new messages
-    await db
-      .update(copilotChats)
-      .set({
-        messages: messages,
-        updatedAt: new Date(),
-      })
-      .where(eq(copilotChats.id, chatId))
+    // Update chat with new messages, plan artifact, and config
+    const updateData: Record<string, any> = {
+      messages: messages,
+      updatedAt: new Date(),
+    }
+
+    if (planArtifact !== undefined) {
+      updateData.planArtifact = planArtifact
+    }
+
+    if (config !== undefined) {
+      updateData.config = config
+    }
+
+    await db.update(copilotChats).set(updateData).where(eq(copilotChats.id, chatId))
 
-    logger.info(`[${tracker.requestId}] Successfully updated chat messages`, {
+    logger.info(`[${tracker.requestId}] Successfully updated chat`, {
       chatId,
       newMessageCount: messages.length,
+      hasPlanArtifact: !!planArtifact,
+      hasConfig: !!config,
     })
 
     return NextResponse.json({

apps/sim/app/api/templates/approved/sanitized/route.ts

@@ -0,0 +1,140 @@
+import { db } from '@sim/db'
+import { templates } from '@sim/db/schema'
+import { eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { checkInternalApiKey } from '@/lib/copilot/utils'
+import { createLogger } from '@/lib/logs/console/logger'
+import { generateRequestId } from '@/lib/utils'
+import { sanitizeForCopilot } from '@/lib/workflows/json-sanitizer'
+
+const logger = createLogger('TemplatesSanitizedAPI')
+
+export const revalidate = 0
+
+/**
+ * GET /api/templates/approved/sanitized
+ * Returns all approved templates with their sanitized JSONs, names, and descriptions
+ * Requires internal API secret authentication via X-API-Key header
+ */
+export async function GET(request: NextRequest) {
+  const requestId = generateRequestId()
+
+  try {
+    const url = new URL(request.url)
+    const hasApiKey = !!request.headers.get('x-api-key')
+
+    // Check internal API key authentication
+    const authResult = checkInternalApiKey(request)
+    if (!authResult.success) {
+      logger.warn(`[${requestId}] Authentication failed for approved sanitized templates`, {
+        error: authResult.error,
+        hasApiKey,
+        howToUse: 'Add header: X-API-Key: <INTERNAL_API_SECRET>',
+      })
+      return NextResponse.json(
+        {
+          error: authResult.error,
+          hint: 'Include X-API-Key header with INTERNAL_API_SECRET value',
+        },
+        { status: 401 }
+      )
+    }
+
+    // Fetch all approved templates
+    const approvedTemplates = await db
+      .select({
+        id: templates.id,
+        name: templates.name,
+        details: templates.details,
+        state: templates.state,
+        tags: templates.tags,
+        requiredCredentials: templates.requiredCredentials,
+      })
+      .from(templates)
+      .where(eq(templates.status, 'approved'))
+
+    // Process each template to sanitize for copilot
+    const sanitizedTemplates = approvedTemplates
+      .map((template) => {
+        try {
+          const copilotSanitized = sanitizeForCopilot(template.state as any)
+
+          if (copilotSanitized?.blocks) {
+            Object.values(copilotSanitized.blocks).forEach((block: any) => {
+              if (block && typeof block === 'object') {
+                block.outputs = undefined
+                block.position = undefined
+                block.height = undefined
+                block.layout = undefined
+                block.horizontalHandles = undefined
+
+                // Also clean nested nodes recursively
+                if (block.nestedNodes) {
+                  Object.values(block.nestedNodes).forEach((nestedBlock: any) => {
+                    if (nestedBlock && typeof nestedBlock === 'object') {
+                      nestedBlock.outputs = undefined
+                      nestedBlock.position = undefined
+                      nestedBlock.height = undefined
+                      nestedBlock.layout = undefined
+                      nestedBlock.horizontalHandles = undefined
+                    }
+                  })
+                }
+              }
+            })
+          }
+
+          const details = template.details as { tagline?: string; about?: string } | null
+          const description = details?.tagline || details?.about || ''
+
+          return {
+            id: template.id,
+            name: template.name,
+            description,
+            tags: template.tags,
+            requiredCredentials: template.requiredCredentials,
+            sanitizedJson: copilotSanitized,
+          }
+        } catch (error) {
+          logger.error(`[${requestId}] Error sanitizing template ${template.id}`, {
+            error: error instanceof Error ? error.message : String(error),
+          })
+          return null
+        }
+      })
+      .filter((t): t is NonNullable<typeof t> => t !== null)
+
+    const response = {
+      templates: sanitizedTemplates,
+      count: sanitizedTemplates.length,
+    }
+
+    return NextResponse.json(response)
+  } catch (error) {
+    logger.error(`[${requestId}] Error fetching approved sanitized templates`, {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    })
+    return NextResponse.json(
+      {
+        error: 'Internal server error',
+        requestId,
+      },
+      { status: 500 }
+    )
+  }
+}
+
+// Add a helpful OPTIONS handler for CORS preflight
+export async function OPTIONS(request: NextRequest) {
+  const requestId = generateRequestId()
+  logger.info(`[${requestId}] OPTIONS request received for /api/templates/approved/sanitized`)
+
+  return new NextResponse(null, {
+    status: 200,
+    headers: {
+      'Access-Control-Allow-Methods': 'GET, OPTIONS',
+      'Access-Control-Allow-Headers': 'X-API-Key, Content-Type',
+    },
+  })
+}

apps/sim/app/api/workflows/[id]/state/route.ts

@@ -4,6 +4,7 @@ import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { getSession } from '@/lib/auth'
+import { env } from '@/lib/env'
 import { createLogger } from '@/lib/logs/console/logger'
 import { generateRequestId } from '@/lib/utils'
 import { extractAndPersistCustomTools } from '@/lib/workflows/custom-tools-persistence'
@@ -248,6 +249,26 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
     const elapsed = Date.now() - startTime
     logger.info(`[${requestId}] Successfully saved workflow ${workflowId} state in ${elapsed}ms`)
 
+    try {
+      const socketUrl = env.SOCKET_SERVER_URL || 'http://localhost:3002'
+      const notifyResponse = await fetch(`${socketUrl}/api/workflow-updated`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ workflowId }),
+      })
+
+      if (!notifyResponse.ok) {
+        logger.warn(
+          `[${requestId}] Failed to notify Socket.IO server about workflow ${workflowId} update`
+        )
+      }
+    } catch (notificationError) {
+      logger.warn(
+        `[${requestId}] Error notifying Socket.IO server about workflow ${workflowId} update`,
+        notificationError
+      )
+    }
+
     return NextResponse.json({ success: true, warnings }, { status: 200 })
   } catch (error: any) {
     const elapsed = Date.now() - startTime

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/components/output-select/output-select.tsx

@@ -70,15 +70,17 @@ export function OutputSelect({
   const popoverRef = useRef<HTMLDivElement>(null)
   const contentRef = useRef<HTMLDivElement>(null)
   const blocks = useWorkflowStore((state) => state.blocks)
-  const { isShowingDiff, isDiffReady, diffWorkflow } = useWorkflowDiffStore()
+  const { isShowingDiff, isDiffReady, hasActiveDiff, baselineWorkflow } = useWorkflowDiffStore()
   const subBlockValues = useSubBlockStore((state) =>
     workflowId ? state.workflowValues[workflowId] : null
   )
 
   /**
    * Uses diff blocks when in diff mode, otherwise main blocks
    */
-  const workflowBlocks = isShowingDiff && isDiffReady && diffWorkflow ? diffWorkflow.blocks : blocks
+  const shouldUseBaseline = hasActiveDiff && isDiffReady && !isShowingDiff && baselineWorkflow
+  const workflowBlocks =
+    shouldUseBaseline && baselineWorkflow ? baselineWorkflow.blocks : (blocks as any)
 
   /**
    * Extracts all available workflow outputs for the dropdown
@@ -100,7 +102,7 @@ export function OutputSelect({
     const blockArray = Object.values(workflowBlocks)
     if (blockArray.length === 0) return outputs
 
-    blockArray.forEach((block) => {
+    blockArray.forEach((block: any) => {
       if (block.type === 'starter' || !block?.id || !block?.type) return
 
       const blockName =
@@ -110,8 +112,8 @@ export function OutputSelect({
 
       const blockConfig = getBlock(block.type)
       const responseFormatValue =
-        isShowingDiff && isDiffReady && diffWorkflow
-          ? diffWorkflow.blocks[block.id]?.subBlocks?.responseFormat?.value
+        shouldUseBaseline && baselineWorkflow
+          ? baselineWorkflow.blocks?.[block.id]?.subBlocks?.responseFormat?.value
           : subBlockValues?.[block.id]?.responseFormat
       const responseFormat = parseResponseFormatSafely(responseFormatValue, block.id)
 
@@ -164,7 +166,16 @@ export function OutputSelect({
     })
 
     return outputs
-  }, [workflowBlocks, workflowId, isShowingDiff, isDiffReady, diffWorkflow, blocks, subBlockValues])
+  }, [
+    workflowBlocks,
+    workflowId,
+    isShowingDiff,
+    isDiffReady,
+    baselineWorkflow,
+    blocks,
+    subBlockValues,
+    shouldUseBaseline,
+  ])
 
   /**
    * Checks if an output is currently selected by comparing both ID and label