improvement(mothership): v0.2

.github/CODEOWNERS

@@ -24,5 +24,6 @@
 # Client-side stream consumption, hydration, and reconnect.
 /apps/sim/app/workspace/*/home/hooks/index.ts @simstudioai/mothership
 /apps/sim/app/workspace/*/home/hooks/use-chat.ts @simstudioai/mothership
-/apps/sim/app/workspace/*/home/hooks/use-file-preview-sessions.ts @simstudioai/mothership
+/apps/sim/app/workspace/*/home/hooks/preview/ @simstudioai/mothership
+/apps/sim/app/workspace/*/home/hooks/stream/ @simstudioai/mothership
 /apps/sim/hooks/queries/tasks.ts @simstudioai/mothership

.github/workflows/migrations.yml

@@ -35,8 +35,15 @@ jobs:
       - name: Install dependencies
         run: bun install --frozen-lockfile
 
-      - name: Apply migrations
+      - name: Apply database schema changes
         working-directory: ./packages/db
         env:
           DATABASE_URL: ${{ github.ref == 'refs/heads/main' && secrets.DATABASE_URL || github.ref == 'refs/heads/dev' && secrets.DEV_DATABASE_URL || secrets.STAGING_DATABASE_URL }}
-        run: bun run ./scripts/migrate.ts
+        run: |
+          if [ "${{ github.ref }}" = "refs/heads/dev" ]; then
+            echo "Dev environment detected — pushing schema with drizzle-kit (db:push)"
+            bun run db:push --force
+          else
+            echo "Applying versioned migrations (db:migrate)"
+            bun run ./scripts/migrate.ts
+          fi

apps/docs/components/ui/icon-mapping.ts

@@ -272,6 +272,7 @@ export const blockTypeToIconMap: Record<string, IconComponent> = {
   file: DocumentIcon,
   file_v2: DocumentIcon,
   file_v4: DocumentIcon,
+  file_v5: DocumentIcon,
   findymail: FindymailIcon,
   firecrawl: FirecrawlIcon,
   fireflies: FirefliesIcon,

apps/docs/content/docs/en/triggers/slack.mdx

@@ -32,21 +32,30 @@ Trigger workflow from Slack events like mentions, messages, and reactions
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `event` | object | Slack event data |
-|   ↳ `event_type` | string | Type of Slack event \(e.g., app_mention, message\) |
+|   ↳ `event_type` | string | Type of Slack payload: an Events API event \(e.g., app_mention, message\), an interactivity type \(e.g., block_actions\), or "slash_command" for slash commands |
 |   ↳ `subtype` | string | Message subtype \(e.g., channel_join, channel_leave, bot_message, file_share\). Null for regular user messages |
 |   ↳ `channel` | string | Slack channel ID where the event occurred |
 |   ↳ `channel_name` | string | Human-readable channel name |
 |   ↳ `channel_type` | string | Type of channel \(e.g., channel, group, im, mpim\). Useful for distinguishing DMs from public channels |
 |   ↳ `user` | string | User ID who triggered the event |
 |   ↳ `user_name` | string | Username who triggered the event |
 |   ↳ `bot_id` | string | Bot ID if the message was sent by a bot. Null for human users |
-|   ↳ `text` | string | Message text content |
+|   ↳ `text` | string | Message text content. For slash commands, the text after the command. For interactivity, the source message text \(falls back to the triggering action value\) |
 |   ↳ `timestamp` | string | Message timestamp from the triggering event |
 |   ↳ `thread_ts` | string | Parent thread timestamp \(if message is in a thread\) |
 |   ↳ `team_id` | string | Slack workspace/team ID |
 |   ↳ `event_id` | string | Unique event identifier |
 |   ↳ `reaction` | string | Emoji reaction name \(e.g., thumbsup\). Present for reaction_added/reaction_removed events |
 |   ↳ `item_user` | string | User ID of the original message author. Present for reaction_added/reaction_removed events |
+|   ↳ `command` | string | Slash command name including the leading slash \(e.g., /deploy\). Present for slash commands |
+|   ↳ `action_id` | string | action_id of the first interactive element triggered. Present for block_actions \(button/select clicks\) |
+|   ↳ `action_value` | string | Value carried by the first interactive element \(button value, selected option, date, etc.\). Present for block_actions |
+|   ↳ `actions` | json | Full array of interactive actions from the payload, preserving every element and its value. Present for block_actions |
+|   ↳ `response_url` | string | Temporary URL to post a response back to the originating message or command. Present for interactivity and slash commands |
+|   ↳ `trigger_id` | string | Short-lived trigger ID used to open a modal in response. Present for interactivity and slash commands |
+|   ↳ `callback_id` | string | Callback ID of the shortcut or view. Present for shortcuts and modal submissions |
+|   ↳ `api_app_id` | string | Slack app ID. Present for interactivity and slash commands |
+|   ↳ `message_ts` | string | Timestamp of the message the interaction originated from. Present for block_actions |
 |   ↳ `hasFiles` | boolean | Whether the message has file attachments |
 |   ↳ `files` | file[] | File attachments downloaded from the message \(if includeFiles is enabled and bot token is provided\) |
 

apps/realtime/src/index.ts

@@ -39,6 +39,14 @@ async function main() {
     hasRedis: !!env.REDIS_URL,
   })
 
+  // Register the HTTP handler before Socket.IO attaches: engine.io captures
+  // pre-existing `request` listeners and forwards only non-`/socket.io/`
+  // requests to them, making it the single dispatcher for the shared port.
+  // The handler itself is assigned after the room manager exists, before listen().
+  // biome-ignore lint/style/useConst: must be declared before the request listener closure; assigned only after the room manager exists
+  let httpHandler: ReturnType<typeof createHttpHandler> | undefined
+  httpServer.on('request', (req, res) => httpHandler?.(req, res))
+
   // Create Socket.IO server with Redis adapter if configured
   const io = await createSocketIOServer(httpServer)
 
@@ -49,8 +57,7 @@ async function main() {
   io.use(authenticateSocket)
 
   // Set up HTTP handler for health checks and internal APIs
-  const httpHandler = createHttpHandler(roomManager, logger)
-  httpServer.on('request', httpHandler)
+  httpHandler = createHttpHandler(roomManager, logger)
 
   // Global error handlers
   process.on('uncaughtException', (error) => {

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

@@ -172,3 +172,59 @@ export const GET = withRouteHandler(async (req: NextRequest) => {
     )
   }
 })
+
+export const DELETE = withRouteHandler(async (req: NextRequest) => {
+  const userId = await getAuthorizedAdminUserId()
+  if (!userId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const adminKey = env.MOTHERSHIP_API_ADMIN_KEY
+  if (!adminKey) {
+    return NextResponse.json({ error: 'MOTHERSHIP_API_ADMIN_KEY not configured' }, { status: 500 })
+  }
+
+  const { searchParams } = new URL(req.url)
+  const queryValidation = adminMothershipQuerySchema.safeParse(searchParamsToObject(searchParams))
+  if (!queryValidation.success) return validationErrorResponse(queryValidation.error)
+  const { env: environment, endpoint } = queryValidation.data
+
+  if (!isValidEndpoint(endpoint)) {
+    return NextResponse.json({ error: 'invalid endpoint' }, { status: 400 })
+  }
+
+  const baseUrl = await getMothershipUrl(environment, userId)
+  if (!baseUrl) {
+    return NextResponse.json(
+      { error: `No URL configured for environment: ${environment}` },
+      { status: 400 }
+    )
+  }
+
+  const forwardParams = new URLSearchParams()
+  searchParams.forEach((value, key) => {
+    if (key !== 'env' && key !== 'endpoint') {
+      forwardParams.set(key, value)
+    }
+  })
+
+  const qs = forwardParams.toString()
+  const targetUrl = `${baseUrl}/api/admin/${endpoint}${qs ? `?${qs}` : ''}`
+
+  try {
+    const upstream = await fetch(targetUrl, {
+      method: 'DELETE',
+      headers: { 'x-api-key': adminKey },
+    })
+
+    const data = await upstream.json()
+    return NextResponse.json(data, { status: upstream.status })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error: `Failed to reach mothership (${environment}): ${getErrorMessage(error, 'Unknown error')}`,
+      },
+      { status: 502 }
+    )
+  }
+})

apps/sim/app/api/billing/member-credits/route.ts

@@ -0,0 +1,38 @@
+import { type NextRequest, NextResponse } from 'next/server'
+import { getMyMemberCreditsContract } from '@/lib/api/contracts/organization'
+import { parseRequest } from '@/lib/api/server'
+import { getSession } from '@/lib/auth'
+import { checkOrgMemberUsageLimit } from '@/lib/billing/calculations/usage-monitor'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+/**
+ * GET /api/billing/member-credits?workspaceId=...
+ *
+ * Returns the caller's OWN per-member usage and cap inside the workspace's
+ * organization, in DOLLARS (the DB unit) so the client's `formatCredits` does the
+ * single dollars→credits conversion. Own-data only, so no admin gate (unlike the
+ * org/member admin route). Reuses {@link checkOrgMemberUsageLimit}, which yields a
+ * null limit — and the chip falls back to the plan-level view — whenever no
+ * per-member cap applies: non-hosted, the workspace isn't org-owned, or no cap is
+ * set for this member.
+ */
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const session = await getSession()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const parsed = await parseRequest(getMyMemberCreditsContract, request, {})
+  if (!parsed.success) return parsed.response
+
+  const { workspaceId } = parsed.data.query
+  const { currentUsage, limit } = await checkOrgMemberUsageLimit(session.user.id, workspaceId)
+
+  return NextResponse.json({
+    success: true,
+    data: {
+      usedDollars: currentUsage,
+      limitDollars: limit,
+    },
+  })
+})

apps/sim/app/api/billing/update-cost/route.test.ts

@@ -0,0 +1,134 @@
+/**
+ * @vitest-environment node
+ */
+import { createMockRequest } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  mockCheckInternalApiKey,
+  mockRecordUsage,
+  mockRecordCumulativeUsage,
+  mockCheckAndBillOverageThreshold,
+} = vi.hoisted(() => ({
+  mockCheckInternalApiKey: vi.fn(),
+  mockRecordUsage: vi.fn(),
+  mockRecordCumulativeUsage: vi.fn(),
+  mockCheckAndBillOverageThreshold: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/http', () => ({
+  checkInternalApiKey: mockCheckInternalApiKey,
+}))
+
+vi.mock('@/lib/copilot/request/otel', () => ({
+  withIncomingGoSpan: (
+    _headers: unknown,
+    _span: unknown,
+    _attrs: unknown,
+    fn: (span: { setAttribute: () => void; setAttributes: () => void }) => unknown
+  ) => fn({ setAttribute: vi.fn(), setAttributes: vi.fn() }),
+}))
+
+vi.mock('@/lib/billing/core/usage-log', () => ({
+  recordUsage: mockRecordUsage,
+  recordCumulativeUsage: mockRecordCumulativeUsage,
+}))
+
+vi.mock('@/lib/billing/threshold-billing', () => ({
+  checkAndBillOverageThreshold: mockCheckAndBillOverageThreshold,
+}))
+
+vi.mock('@/lib/core/config/feature-flags', () => ({
+  isBillingEnabled: true,
+}))
+
+import { POST } from '@/app/api/billing/update-cost/route'
+
+describe('POST /api/billing/update-cost — workspaceId attribution', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockCheckInternalApiKey.mockReturnValue({ success: true })
+    mockRecordUsage.mockResolvedValue(undefined)
+    mockRecordCumulativeUsage.mockResolvedValue({ billed: true, delta: 0.5, total: 0.5 })
+    mockCheckAndBillOverageThreshold.mockResolvedValue(undefined)
+  })
+
+  it('stamps workspaceId onto recorded usage when provided (no idempotency key)', async () => {
+    const res = await POST(
+      createMockRequest(
+        'POST',
+        { userId: 'user-1', cost: 0.5, model: 'gpt', source: 'mcp_copilot', workspaceId: 'ws-1' },
+        { 'x-api-key': 'internal' }
+      )
+    )
+    expect(res.status).toBe(200)
+    expect(mockRecordUsage).toHaveBeenCalledTimes(1)
+    expect(mockRecordUsage.mock.calls[0][0]).toMatchObject({
+      userId: 'user-1',
+      workspaceId: 'ws-1',
+    })
+  })
+
+  it('records cumulative cost via monotonic top-up when an idempotency key is present', async () => {
+    const res = await POST(
+      createMockRequest(
+        'POST',
+        {
+          userId: 'user-1',
+          cost: 0.4662453,
+          model: 'claude-opus-4.8',
+          source: 'workspace-chat',
+          workspaceId: 'ws-1',
+          idempotencyKey: 'msg-1-billing',
+          inputTokens: 461371,
+          outputTokens: 1686,
+        },
+        { 'x-api-key': 'internal' }
+      )
+    )
+    expect(res.status).toBe(200)
+    expect(mockRecordUsage).not.toHaveBeenCalled()
+    expect(mockRecordCumulativeUsage).toHaveBeenCalledTimes(1)
+    expect(mockRecordCumulativeUsage.mock.calls[0][0]).toMatchObject({
+      userId: 'user-1',
+      workspaceId: 'ws-1',
+      source: 'workspace-chat',
+      model: 'claude-opus-4.8',
+      cost: 0.4662453,
+      eventKey: 'update-cost:msg-1-billing',
+    })
+    expect(mockCheckAndBillOverageThreshold).toHaveBeenCalledWith('user-1')
+  })
+
+  it('returns 409 and skips overage when the cumulative is not higher (duplicate flush)', async () => {
+    mockRecordCumulativeUsage.mockResolvedValue({ billed: false, delta: 0, total: 0.4662453 })
+    const res = await POST(
+      createMockRequest(
+        'POST',
+        {
+          userId: 'user-1',
+          cost: 0.4662453,
+          model: 'claude-opus-4.8',
+          source: 'workspace-chat',
+          workspaceId: 'ws-1',
+          idempotencyKey: 'msg-1-billing',
+        },
+        { 'x-api-key': 'internal' }
+      )
+    )
+    expect(res.status).toBe(409)
+    expect(mockCheckAndBillOverageThreshold).not.toHaveBeenCalled()
+  })
+
+  it('rejects with 400 when workspaceId is omitted (contract-required, fail loud)', async () => {
+    const res = await POST(
+      createMockRequest(
+        'POST',
+        { userId: 'user-1', cost: 0.5, model: 'gpt', source: 'copilot' },
+        { 'x-api-key': 'internal' }
+      )
+    )
+    expect(res.status).toBe(400)
+    expect(mockRecordUsage).not.toHaveBeenCalled()
+  })
+})