chore: import upstream snapshot with attribution

apps/sim/tools/utils.server.ts

@@ -0,0 +1,179 @@
+import { createLogger } from '@sim/logger'
+import { customToolSchemaSchema } from '@/lib/api/contracts/tools/custom'
+import {
+  secureFetchWithPinnedIP,
+  validateUrlWithDNS,
+} from '@/lib/core/security/input-validation.server'
+import { getCustomToolByIdOrTitle } from '@/lib/workflows/custom-tools/operations'
+import { isCustomTool } from '@/executor/constants'
+import type { CustomToolDefinition } from '@/hooks/queries/custom-tools'
+import { extractErrorMessage } from '@/tools/error-extractors'
+import { tools } from '@/tools/registry'
+import type { ToolConfig, ToolResponse } from '@/tools/types'
+import type { RequestParams } from '@/tools/utils'
+import {
+  createCustomToolRequestBody,
+  createParamSchema,
+  createToolConfig,
+  resolveToolId,
+} from '@/tools/utils'
+
+const logger = createLogger('ToolsUtils')
+
+export interface GetToolAsyncContext {
+  workflowId?: string
+  userId?: string
+  workspaceId?: string
+}
+
+type CustomToolRow = NonNullable<Awaited<ReturnType<typeof getCustomToolByIdOrTitle>>>
+
+function toCustomToolDefinition(customTool: CustomToolRow): CustomToolDefinition | null {
+  const parsedSchema = customToolSchemaSchema.safeParse(customTool.schema)
+  if (!parsedSchema.success) {
+    logger.error(`Invalid custom tool schema: ${customTool.id}`, {
+      issues: parsedSchema.error.issues,
+    })
+    return null
+  }
+
+  return {
+    id: customTool.id,
+    workspaceId: customTool.workspaceId,
+    userId: customTool.userId,
+    title: customTool.title,
+    schema: parsedSchema.data,
+    code: customTool.code,
+    createdAt: customTool.createdAt.toISOString(),
+    updatedAt: customTool.updatedAt?.toISOString(),
+  }
+}
+
+/**
+ * Execute the actual request and transform the response.
+ * Server-only: uses DNS validation and IP-pinned fetch.
+ */
+export async function executeRequest(
+  toolId: string,
+  tool: ToolConfig,
+  requestParams: RequestParams
+): Promise<ToolResponse> {
+  try {
+    const { url, method, headers, body } = requestParams
+    const isExternalUrl = url.startsWith('http://') || url.startsWith('https://')
+    const externalResponse = isExternalUrl
+      ? (() => {
+          return validateUrlWithDNS(url, 'url').then((urlValidation) => {
+            if (!urlValidation.isValid) {
+              throw new Error(urlValidation.error)
+            }
+            return secureFetchWithPinnedIP(url, urlValidation.resolvedIP!, {
+              method,
+              headers,
+              body,
+            })
+          })
+        })()
+      : fetch(url, { method, headers, body })
+
+    const resolvedResponse = await externalResponse
+
+    if (!resolvedResponse.ok) {
+      let errorData: any
+      try {
+        errorData = await resolvedResponse.json()
+      } catch (_e) {
+        try {
+          errorData = await resolvedResponse.text()
+        } catch (_e2) {
+          errorData = null
+        }
+      }
+
+      const error = extractErrorMessage({
+        status: resolvedResponse.status,
+        statusText: resolvedResponse.statusText,
+        data: errorData,
+      })
+      logger.error(`${toolId} error:`, { error })
+      throw new Error(error)
+    }
+
+    const transformResponse =
+      tool.transformResponse ||
+      (async (resp: Response) => ({
+        success: true,
+        output: await resp.json(),
+      }))
+
+    return await transformResponse(resolvedResponse as Response)
+  } catch (error: any) {
+    return {
+      success: false,
+      output: {},
+      error: error.message || 'Unknown error',
+    }
+  }
+}
+
+// Get a tool by its ID asynchronously (supports server-side)
+export async function getToolAsync(
+  toolId: string,
+  context: GetToolAsyncContext = {}
+): Promise<ToolConfig | undefined> {
+  const builtInTool = tools[resolveToolId(toolId)]
+  if (builtInTool) return builtInTool
+
+  if (isCustomTool(toolId)) {
+    return fetchCustomToolFromDB(toolId, context)
+  }
+
+  return undefined
+}
+
+async function fetchCustomToolFromDB(
+  customToolId: string,
+  context: GetToolAsyncContext
+): Promise<ToolConfig | undefined> {
+  const { workflowId, userId, workspaceId } = context
+  const identifier = customToolId.replace('custom_', '')
+
+  if (!userId) {
+    throw new Error(`Cannot fetch custom tool without userId: ${identifier}`)
+  }
+  if (!workspaceId) {
+    throw new Error(`Cannot fetch custom tool without workspaceId: ${identifier}`)
+  }
+
+  try {
+    const customTool = await getCustomToolByIdOrTitle({
+      identifier,
+      userId,
+      workspaceId,
+    })
+
+    if (!customTool) {
+      logger.error(`Custom tool not found: ${identifier}`)
+      return undefined
+    }
+
+    const customToolDefinition = toCustomToolDefinition(customTool)
+    if (!customToolDefinition) {
+      return undefined
+    }
+
+    const toolConfig = createToolConfig(customToolDefinition, customToolId)
+
+    return {
+      ...toolConfig,
+      params: createParamSchema(customTool),
+      request: {
+        ...toolConfig.request,
+        body: createCustomToolRequestBody(customTool, false, workflowId),
+      },
+    }
+  } catch (error) {
+    logger.error(`Error fetching custom tool ${identifier} from DB:`, error)
+    return undefined
+  }
+}