chore: import upstream snapshot with attribution

apps/sim/app/api/mothership/chats/read/route.test.ts

@@ -0,0 +1,93 @@
+/**
+ * @vitest-environment node
+ */
+import { copilotHttpMock, copilotHttpMockFns } from '@sim/testing'
+import { NextRequest } from 'next/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockUpdate, mockSet, mockWhere, mockParseRequest } = vi.hoisted(() => ({
+  mockUpdate: vi.fn(),
+  mockSet: vi.fn(),
+  mockWhere: vi.fn(),
+  mockParseRequest: vi.fn(),
+}))
+
+vi.mock('@sim/db', () => ({
+  db: { update: mockUpdate },
+}))
+
+vi.mock('@sim/db/schema', () => ({
+  copilotChats: {
+    id: 'copilotChats.id',
+    userId: 'copilotChats.userId',
+    updatedAt: 'copilotChats.updatedAt',
+    lastSeenAt: 'copilotChats.lastSeenAt',
+  },
+}))
+
+vi.mock('drizzle-orm', () => ({
+  and: vi.fn((...conditions: unknown[]) => ({ type: 'and', conditions })),
+  eq: vi.fn((field: unknown, value: unknown) => ({ type: 'eq', field, value })),
+  or: vi.fn((...conditions: unknown[]) => ({ type: 'or', conditions })),
+  isNull: vi.fn((field: unknown) => ({ type: 'isNull', field })),
+  lt: vi.fn((field: unknown, value: unknown) => ({ type: 'lt', field, value })),
+  sql: vi.fn(() => ({ type: 'sql' })),
+}))
+
+vi.mock('@/lib/copilot/request/http', () => copilotHttpMock)
+vi.mock('@/lib/api/server', () => ({ parseRequest: mockParseRequest }))
+vi.mock('@/lib/api/contracts/mothership-chats', () => ({ markMothershipChatReadContract: {} }))
+
+import { POST } from '@/app/api/mothership/chats/read/route'
+
+function createRequest() {
+  return new NextRequest('http://localhost:3000/api/mothership/chats/read', {
+    method: 'POST',
+    body: JSON.stringify({ chatId: 'chat-1' }),
+  })
+}
+
+describe('POST /api/mothership/chats/read', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    copilotHttpMockFns.mockAuthenticateCopilotRequestSessionOnly.mockResolvedValue({
+      userId: 'user-1',
+      isAuthenticated: true,
+    })
+    mockParseRequest.mockResolvedValue({ success: true, data: { body: { chatId: 'chat-1' } } })
+    mockWhere.mockResolvedValue(undefined)
+    mockSet.mockReturnValue({ where: mockWhere })
+    mockUpdate.mockReturnValue({ set: mockSet })
+  })
+
+  it('guards the lastSeenAt write with the unread predicate (only writes when unread)', async () => {
+    const res = await POST(createRequest())
+    expect(res.status).toBe(200)
+
+    expect(mockUpdate).toHaveBeenCalledTimes(1)
+    const whereArg = mockWhere.mock.calls[0][0] as {
+      type: string
+      conditions: Array<{ type: string; conditions?: unknown[] }>
+    }
+    expect(whereArg.type).toBe('and')
+
+    const orClause = whereArg.conditions.find((c) => c.type === 'or')
+    expect(orClause).toBeDefined()
+    expect(orClause?.conditions).toEqual(
+      expect.arrayContaining([
+        { type: 'isNull', field: 'copilotChats.lastSeenAt' },
+        { type: 'lt', field: 'copilotChats.lastSeenAt', value: 'copilotChats.updatedAt' },
+      ])
+    )
+  })
+
+  it('does not touch the database when unauthenticated', async () => {
+    copilotHttpMockFns.mockAuthenticateCopilotRequestSessionOnly.mockResolvedValue({
+      userId: null,
+      isAuthenticated: false,
+    })
+    const res = await POST(createRequest())
+    expect(res.status).toBe(401)
+    expect(mockUpdate).not.toHaveBeenCalled()
+  })
+})

apps/sim/app/api/mothership/chats/read/route.ts

@@ -0,0 +1,44 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, isNull, lt, or, sql } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { markMothershipChatReadContract } from '@/lib/api/contracts/mothership-chats'
+import { parseRequest } from '@/lib/api/server'
+import {
+  authenticateCopilotRequestSessionOnly,
+  createInternalServerErrorResponse,
+  createUnauthorizedResponse,
+} from '@/lib/copilot/request/http'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+const logger = createLogger('MarkTaskReadAPI')
+
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  try {
+    const { userId, isAuthenticated } = await authenticateCopilotRequestSessionOnly()
+    if (!isAuthenticated || !userId) {
+      return createUnauthorizedResponse()
+    }
+
+    const parsed = await parseRequest(markMothershipChatReadContract, request, {})
+    if (!parsed.success) return parsed.response
+    const { chatId } = parsed.data.body
+
+    await db
+      .update(copilotChats)
+      .set({ lastSeenAt: sql`GREATEST(${copilotChats.updatedAt}, NOW())` })
+      .where(
+        and(
+          eq(copilotChats.id, chatId),
+          eq(copilotChats.userId, userId),
+          or(isNull(copilotChats.lastSeenAt), lt(copilotChats.lastSeenAt, copilotChats.updatedAt))
+        )
+      )
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    logger.error('Error marking task as read:', error)
+    return createInternalServerErrorResponse('Failed to mark task as read')
+  }
+})