chore: import upstream snapshot with attribution

apps/sim/app/api/v1/admin/workflows/[id]/deploy/route.ts

@@ -0,0 +1,122 @@
+import { createLogger } from '@sim/logger'
+import { getActiveWorkflowRecord } from '@sim/platform-authz/workflow'
+import {
+  adminV1DeployWorkflowContract,
+  adminV1UndeployWorkflowContract,
+} from '@/lib/api/contracts/v1/admin'
+import { parseRequest } from '@/lib/api/server'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { performFullDeploy, performFullUndeploy } from '@/lib/workflows/orchestration'
+import { withAdminAuthParams } from '@/app/api/v1/admin/middleware'
+import {
+  badRequestResponse,
+  internalErrorResponse,
+  notFoundResponse,
+  singleResponse,
+} from '@/app/api/v1/admin/responses'
+import type { AdminDeployResult, AdminUndeployResult } from '@/app/api/v1/admin/types'
+
+const logger = createLogger('AdminWorkflowDeployAPI')
+export const maxDuration = 120
+
+interface RouteParams {
+  id: string
+}
+
+/**
+ * POST — Deploy a workflow via admin API.
+ *
+ * `userId` is set to the workflow owner so that webhook credential resolution
+ * (OAuth token lookups for providers like Airtable, Attio, etc.) uses a real
+ * user. `actorId` is set to `'admin-api'` so that the `deployedBy` field on
+ * the deployment version and audit log entries are correctly attributed to an
+ * admin action rather than the workflow owner.
+ */
+export const POST = withRouteHandler(
+  withAdminAuthParams<RouteParams>(async (request, context) => {
+    const parsed = await parseRequest(adminV1DeployWorkflowContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { id: workflowId } = parsed.data.params
+    const requestId = generateRequestId()
+
+    try {
+      const workflowRecord = await getActiveWorkflowRecord(workflowId)
+
+      if (!workflowRecord) {
+        return notFoundResponse('Workflow')
+      }
+
+      const result = await performFullDeploy({
+        workflowId,
+        userId: workflowRecord.userId,
+        workflowName: workflowRecord.name,
+        requestId,
+        request,
+        actorId: 'admin-api',
+      })
+
+      if (!result.success) {
+        if (result.errorCode === 'not_found') return notFoundResponse('Workflow state')
+        if (result.errorCode === 'validation') return badRequestResponse(result.error!)
+        return internalErrorResponse(result.error || 'Failed to deploy workflow')
+      }
+
+      logger.info(`[${requestId}] Admin API: Deployed workflow ${workflowId} as v${result.version}`)
+
+      const response: AdminDeployResult = {
+        isDeployed: true,
+        version: result.version!,
+        deployedAt: result.deployedAt!.toISOString(),
+        warnings: result.warnings,
+      }
+
+      return singleResponse(response)
+    } catch (error) {
+      logger.error(`Admin API: Failed to deploy workflow ${workflowId}`, { error })
+      return internalErrorResponse('Failed to deploy workflow')
+    }
+  })
+)
+
+export const DELETE = withRouteHandler(
+  withAdminAuthParams<RouteParams>(async (request, context) => {
+    const parsed = await parseRequest(adminV1UndeployWorkflowContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { id: workflowId } = parsed.data.params
+    const requestId = generateRequestId()
+
+    try {
+      const workflowRecord = await getActiveWorkflowRecord(workflowId)
+
+      if (!workflowRecord) {
+        return notFoundResponse('Workflow')
+      }
+
+      const result = await performFullUndeploy({
+        workflowId,
+        userId: workflowRecord.userId,
+        requestId,
+        actorId: 'admin-api',
+      })
+
+      if (!result.success) {
+        return internalErrorResponse(result.error || 'Failed to undeploy workflow')
+      }
+
+      logger.info(`Admin API: Undeployed workflow ${workflowId}`)
+
+      const response: AdminUndeployResult = {
+        isDeployed: false,
+        warnings: result.warnings,
+      }
+
+      return singleResponse(response)
+    } catch (error) {
+      logger.error(`Admin API: Failed to undeploy workflow ${workflowId}`, { error })
+      return internalErrorResponse('Failed to undeploy workflow')
+    }
+  })
+)

apps/sim/app/api/v1/admin/workflows/[id]/export/route.ts

@@ -0,0 +1,95 @@
+/**
+ * GET /api/v1/admin/workflows/[id]/export
+ *
+ * Export a single workflow as JSON (raw, unsanitized for admin backup/restore).
+ *
+ * Response: AdminSingleResponse<WorkflowExportPayload>
+ */
+
+import { db } from '@sim/db'
+import { workflow } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
+import { adminV1ExportWorkflowContract } from '@/lib/api/contracts/v1/admin'
+import { parseRequest } from '@/lib/api/server'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
+import { withAdminAuthParams } from '@/app/api/v1/admin/middleware'
+import {
+  internalErrorResponse,
+  notFoundResponse,
+  singleResponse,
+} from '@/app/api/v1/admin/responses'
+import {
+  parseWorkflowVariables,
+  type WorkflowExportPayload,
+  type WorkflowExportState,
+} from '@/app/api/v1/admin/types'
+
+const logger = createLogger('AdminWorkflowExportAPI')
+
+interface RouteParams {
+  id: string
+}
+
+export const GET = withRouteHandler(
+  withAdminAuthParams<RouteParams>(async (request, context) => {
+    const parsed = await parseRequest(adminV1ExportWorkflowContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { id: workflowId } = parsed.data.params
+
+    try {
+      const [workflowData] = await db
+        .select()
+        .from(workflow)
+        .where(eq(workflow.id, workflowId))
+        .limit(1)
+
+      if (!workflowData) {
+        return notFoundResponse('Workflow')
+      }
+
+      const normalizedData = await loadWorkflowFromNormalizedTables(workflowId)
+
+      if (!normalizedData) {
+        return notFoundResponse('Workflow state')
+      }
+
+      const variables = parseWorkflowVariables(workflowData.variables)
+
+      const state: WorkflowExportState = {
+        blocks: normalizedData.blocks,
+        edges: normalizedData.edges,
+        loops: normalizedData.loops,
+        parallels: normalizedData.parallels,
+        metadata: {
+          name: workflowData.name,
+          description: workflowData.description ?? undefined,
+          exportedAt: new Date().toISOString(),
+        },
+        variables,
+      }
+
+      const exportPayload: WorkflowExportPayload = {
+        version: '1.0',
+        exportedAt: new Date().toISOString(),
+        workflow: {
+          id: workflowData.id,
+          name: workflowData.name,
+          description: workflowData.description,
+          workspaceId: workflowData.workspaceId,
+          folderId: workflowData.folderId,
+        },
+        state,
+      }
+
+      logger.info(`Admin API: Exported workflow ${workflowId}`)
+
+      return singleResponse(exportPayload)
+    } catch (error) {
+      logger.error('Admin API: Failed to export workflow', { error, workflowId })
+      return internalErrorResponse('Failed to export workflow')
+    }
+  })
+)

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

@@ -0,0 +1,117 @@
+/**
+ * GET /api/v1/admin/workflows/[id]
+ *
+ * Get workflow details including block and edge counts.
+ *
+ * Response: AdminSingleResponse<AdminWorkflowDetail>
+ *
+ * DELETE /api/v1/admin/workflows/[id]
+ *
+ * Delete a workflow and all its associated data.
+ *
+ * Response: { success: true, workflowId: string }
+ */
+
+import { db } from '@sim/db'
+import { workflowBlocks, workflowEdges } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { getActiveWorkflowRecord } from '@sim/platform-authz/workflow'
+import { count, eq } from 'drizzle-orm'
+import { NextResponse } from 'next/server'
+import {
+  adminV1DeleteWorkflowContract,
+  adminV1GetWorkflowContract,
+} from '@/lib/api/contracts/v1/admin'
+import { parseRequest } from '@/lib/api/server'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { performDeleteWorkflow } from '@/lib/workflows/orchestration'
+import { withAdminAuthParams } from '@/app/api/v1/admin/middleware'
+import {
+  internalErrorResponse,
+  notFoundResponse,
+  singleResponse,
+} from '@/app/api/v1/admin/responses'
+import { type AdminWorkflowDetail, toAdminWorkflow } from '@/app/api/v1/admin/types'
+
+const logger = createLogger('AdminWorkflowDetailAPI')
+
+interface RouteParams {
+  id: string
+}
+
+export const GET = withRouteHandler(
+  withAdminAuthParams<RouteParams>(async (request, context) => {
+    const parsed = await parseRequest(adminV1GetWorkflowContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { id: workflowId } = parsed.data.params
+
+    try {
+      const workflowData = await getActiveWorkflowRecord(workflowId)
+
+      if (!workflowData) {
+        return notFoundResponse('Workflow')
+      }
+
+      const [blockCountResult, edgeCountResult] = await Promise.all([
+        db
+          .select({ count: count() })
+          .from(workflowBlocks)
+          .where(eq(workflowBlocks.workflowId, workflowId)),
+        db
+          .select({ count: count() })
+          .from(workflowEdges)
+          .where(eq(workflowEdges.workflowId, workflowId)),
+      ])
+
+      const data: AdminWorkflowDetail = {
+        ...toAdminWorkflow(workflowData),
+        blockCount: blockCountResult[0].count,
+        edgeCount: edgeCountResult[0].count,
+      }
+
+      logger.info(`Admin API: Retrieved workflow ${workflowId}`)
+
+      return singleResponse(data)
+    } catch (error) {
+      logger.error('Admin API: Failed to get workflow', { error, workflowId })
+      return internalErrorResponse('Failed to get workflow')
+    }
+  })
+)
+
+export const DELETE = withRouteHandler(
+  withAdminAuthParams<RouteParams>(async (request, context) => {
+    const parsed = await parseRequest(adminV1DeleteWorkflowContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { id: workflowId } = parsed.data.params
+
+    try {
+      const workflowData = await getActiveWorkflowRecord(workflowId)
+
+      if (!workflowData) {
+        return notFoundResponse('Workflow')
+      }
+
+      const result = await performDeleteWorkflow({
+        workflowId,
+        userId: workflowData.userId,
+        skipLastWorkflowGuard: true,
+        requestId: `admin-workflow-${workflowId}`,
+        actorId: 'admin-api',
+      })
+
+      if (!result.success) {
+        return internalErrorResponse(result.error || 'Failed to delete workflow')
+      }
+
+      logger.info(`Admin API: Deleted workflow ${workflowId} (${workflowData.name})`)
+
+      return NextResponse.json({ success: true, workflowId })
+    } catch (error) {
+      logger.error('Admin API: Failed to delete workflow', { error, workflowId })
+      return internalErrorResponse('Failed to delete workflow')
+    }
+  })
+)

apps/sim/app/api/v1/admin/workflows/[id]/versions/[versionId]/activate/route.ts

@@ -0,0 +1,73 @@
+import { createLogger } from '@sim/logger'
+import { getActiveWorkflowRecord } from '@sim/platform-authz/workflow'
+import { adminV1ActivateWorkflowVersionContract } from '@/lib/api/contracts/v1/admin'
+import { parseRequest } from '@/lib/api/server'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { performActivateVersion } from '@/lib/workflows/orchestration'
+import { withAdminAuthParams } from '@/app/api/v1/admin/middleware'
+import {
+  badRequestResponse,
+  internalErrorResponse,
+  notFoundResponse,
+  singleResponse,
+} from '@/app/api/v1/admin/responses'
+
+const logger = createLogger('AdminWorkflowActivateVersionAPI')
+export const maxDuration = 120
+
+interface RouteParams {
+  id: string
+  versionId: string
+}
+
+export const POST = withRouteHandler(
+  withAdminAuthParams<RouteParams>(async (request, context) => {
+    const requestId = generateRequestId()
+    const parsed = await parseRequest(adminV1ActivateWorkflowVersionContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { id: workflowId, versionId: versionNum } = parsed.data.params
+
+    try {
+      const workflowRecord = await getActiveWorkflowRecord(workflowId)
+
+      if (!workflowRecord) {
+        return notFoundResponse('Workflow')
+      }
+
+      const result = await performActivateVersion({
+        workflowId,
+        version: versionNum,
+        userId: workflowRecord.userId,
+        workflow: workflowRecord as Record<string, unknown>,
+        requestId,
+        request,
+        actorId: 'admin-api',
+      })
+
+      if (!result.success) {
+        if (result.errorCode === 'not_found') return notFoundResponse('Deployment version')
+        if (result.errorCode === 'validation') return badRequestResponse(result.error!)
+        return internalErrorResponse(result.error || 'Failed to activate version')
+      }
+
+      logger.info(
+        `[${requestId}] Admin API: Activated version ${versionNum} for workflow ${workflowId}`
+      )
+
+      return singleResponse({
+        success: true,
+        version: versionNum,
+        deployedAt: result.deployedAt!.toISOString(),
+        warnings: result.warnings,
+      })
+    } catch (error) {
+      logger.error(
+        `[${requestId}] Admin API: Failed to activate version for workflow ${workflowId}`,
+        { error }
+      )
+      return internalErrorResponse('Failed to activate deployment version')
+    }
+  })
+)

apps/sim/app/api/v1/admin/workflows/[id]/versions/route.ts

@@ -0,0 +1,55 @@
+import { createLogger } from '@sim/logger'
+import { getActiveWorkflowRecord } from '@sim/platform-authz/workflow'
+import { adminV1ListWorkflowVersionsContract } from '@/lib/api/contracts/v1/admin'
+import { parseRequest } from '@/lib/api/server'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { listWorkflowVersions } from '@/lib/workflows/persistence/utils'
+import { withAdminAuthParams } from '@/app/api/v1/admin/middleware'
+import {
+  internalErrorResponse,
+  notFoundResponse,
+  singleResponse,
+} from '@/app/api/v1/admin/responses'
+import type { AdminDeploymentVersion } from '@/app/api/v1/admin/types'
+
+const logger = createLogger('AdminWorkflowVersionsAPI')
+
+interface RouteParams {
+  id: string
+}
+
+export const GET = withRouteHandler(
+  withAdminAuthParams<RouteParams>(async (request, context) => {
+    const parsed = await parseRequest(adminV1ListWorkflowVersionsContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { id: workflowId } = parsed.data.params
+
+    try {
+      const workflowRecord = await getActiveWorkflowRecord(workflowId)
+
+      if (!workflowRecord) {
+        return notFoundResponse('Workflow')
+      }
+
+      const { versions } = await listWorkflowVersions(workflowId)
+
+      const response: AdminDeploymentVersion[] = versions.map((v) => ({
+        id: v.id,
+        version: v.version,
+        name: v.name,
+        isActive: v.isActive,
+        createdAt: v.createdAt.toISOString(),
+        createdBy: v.createdBy,
+        deployedByName: v.deployedByName,
+      }))
+
+      logger.info(`Admin API: Listed ${versions.length} versions for workflow ${workflowId}`)
+
+      return singleResponse({ versions: response })
+    } catch (error) {
+      logger.error(`Admin API: Failed to list versions for workflow ${workflowId}`, { error })
+      return internalErrorResponse('Failed to list deployment versions')
+    }
+  })
+)