chore: import upstream snapshot with attribution

apps/sim/tools/jira/utils.ts

@@ -0,0 +1,256 @@
+import { createLogger } from '@sim/logger'
+import type { RetryOptions } from '@/lib/knowledge/documents/utils'
+import { fetchWithRetry } from '@/lib/knowledge/documents/utils'
+
+const logger = createLogger('JiraUtils')
+
+const MAX_ATTACHMENT_SIZE = 50 * 1024 * 1024
+
+/**
+ * Converts a value to ADF format. If the value is already an ADF document object,
+ * it is returned as-is. If it is a plain string, it is wrapped in a single-paragraph ADF doc.
+ */
+export function toAdf(value: string | Record<string, unknown>): Record<string, unknown> {
+  if (typeof value === 'object') {
+    if (value.type === 'doc') {
+      return value
+    }
+    if (value.type && Array.isArray(value.content)) {
+      return { type: 'doc', version: 1, content: [value] }
+    }
+  }
+  if (typeof value === 'string') {
+    try {
+      const parsed = JSON.parse(value)
+      if (typeof parsed === 'object' && parsed !== null && parsed.type === 'doc') {
+        return parsed
+      }
+      if (
+        typeof parsed === 'object' &&
+        parsed !== null &&
+        parsed.type &&
+        Array.isArray(parsed.content)
+      ) {
+        return { type: 'doc', version: 1, content: [parsed] }
+      }
+    } catch {
+      // Not JSON — treat as plain text below
+    }
+  }
+  return {
+    type: 'doc',
+    version: 1,
+    content: [
+      {
+        type: 'paragraph',
+        content: [
+          { type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value) },
+        ],
+      },
+    ],
+  }
+}
+
+/**
+ * Extracts plain text from Atlassian Document Format (ADF) content.
+ * Returns null if content is falsy.
+ */
+export function extractAdfText(content: any): string | null {
+  if (!content) return null
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content.map(extractAdfText).filter(Boolean).join(' ')
+  }
+  if (content.type === 'text') return content.text || ''
+  if (content.type === 'hardBreak') return '\n'
+  if (content.type === 'mention') return content.attrs?.text || ''
+  if (content.type === 'emoji') return content.attrs?.shortName || content.attrs?.text || ''
+  if (content.content) return extractAdfText(content.content)
+  return ''
+}
+
+/**
+ * Transforms a raw Jira API user object into a typed user output.
+ * Returns null if user data is falsy.
+ */
+export function transformUser(user: any): {
+  accountId: string
+  displayName: string
+  active: boolean | null
+  emailAddress: string | null
+  avatarUrl: string | null
+  accountType: string | null
+  timeZone: string | null
+} | null {
+  if (!user) return null
+  return {
+    accountId: user.accountId ?? '',
+    displayName: user.displayName ?? '',
+    active: user.active ?? null,
+    emailAddress: user.emailAddress ?? null,
+    avatarUrl: user.avatarUrls?.['48x48'] ?? null,
+    accountType: user.accountType ?? null,
+    timeZone: user.timeZone ?? null,
+  }
+}
+
+/**
+ * Downloads Jira attachment file content given attachment metadata and an access token.
+ * Returns an array of downloaded files with base64-encoded data.
+ */
+export async function downloadJiraAttachments(
+  attachments: Array<{
+    content: string
+    filename: string
+    mimeType: string
+    size: number
+    id: string
+  }>,
+  accessToken: string
+): Promise<Array<{ name: string; mimeType: string; data: string; size: number }>> {
+  const downloaded: Array<{ name: string; mimeType: string; data: string; size: number }> = []
+
+  for (const att of attachments) {
+    if (!att.content) continue
+    if (att.size > MAX_ATTACHMENT_SIZE) {
+      logger.warn(`Skipping attachment ${att.filename} (${att.size} bytes): exceeds size limit`)
+      continue
+    }
+    try {
+      const response = await fetchWithRetry(att.content, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          Accept: '*/*',
+        },
+      })
+
+      if (!response.ok) {
+        logger.warn(`Failed to download attachment ${att.filename}: HTTP ${response.status}`)
+        continue
+      }
+
+      const arrayBuffer = await response.arrayBuffer()
+      const buffer = Buffer.from(arrayBuffer)
+
+      downloaded.push({
+        name: att.filename || `attachment-${att.id}`,
+        mimeType: att.mimeType || 'application/octet-stream',
+        data: buffer.toString('base64'),
+        size: buffer.length,
+      })
+    } catch (error) {
+      logger.warn(`Failed to download attachment ${att.filename}:`, error)
+    }
+  }
+
+  return downloaded
+}
+
+/**
+ * Normalizes an ISO timestamp into the format Jira's worklog API requires:
+ * `YYYY-MM-DDTHH:mm:ss.sss±HHMM` (offset without colon). Accepts trailing `Z`
+ * and `±HH:MM` offsets and rewrites them to `±HHMM`. If milliseconds are
+ * missing, `.000` is inserted before the offset.
+ */
+export function normalizeJiraWorklogTimestamp(value: string): string {
+  let s = value.trim()
+  s = s.replace(/Z$/i, '+0000')
+  s = s.replace(/([+-]\d{2}):(\d{2})$/, '$1$2')
+  s = s.replace(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})([+-]\d{4})$/, '$1.000$2')
+  return s
+}
+
+export function normalizeDomain(domain: string): string {
+  return `https://${domain
+    .trim()
+    .replace(/^https?:\/\//i, '')
+    .replace(/\/+$/, '')}`.toLowerCase()
+}
+
+export async function getJiraCloudId(
+  domain: string,
+  accessToken: string,
+  retryOptions?: RetryOptions
+): Promise<string> {
+  const response = await fetchWithRetry(
+    'https://api.atlassian.com/oauth/token/accessible-resources',
+    {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/json',
+      },
+    },
+    retryOptions
+  )
+
+  if (!response.ok) {
+    const errorText = await response.text()
+    throw new Error(`Failed to fetch Jira accessible resources: ${response.status} - ${errorText}`)
+  }
+
+  const resources = await response.json()
+
+  if (!Array.isArray(resources) || resources.length === 0) {
+    throw new Error('No Jira resources found')
+  }
+
+  const normalized = normalizeDomain(domain)
+  const match = resources.find(
+    (r: { url: string }) => r.url.toLowerCase().replace(/\/+$/, '') === normalized
+  )
+
+  if (match) {
+    return match.id
+  }
+
+  if (resources.length === 1) {
+    return resources[0].id
+  }
+
+  throw new Error(
+    `Could not match Jira domain "${domain}" to any accessible resource. ` +
+      `Available sites: ${resources.map((r: { url: string }) => r.url).join(', ')}`
+  )
+}
+
+/**
+ * Parse error messages from Atlassian API responses (Jira, JSM, Confluence).
+ * Handles all known error formats: errorMessage, errorMessages[], errors[].title/detail,
+ * field-level errors object, and generic message fallback.
+ */
+export function parseAtlassianErrorMessage(
+  status: number,
+  statusText: string,
+  errorText: string
+): string {
+  try {
+    const errorData = JSON.parse(errorText)
+    if (errorData.errorMessage) {
+      return errorData.errorMessage
+    }
+    if (Array.isArray(errorData.errorMessages) && errorData.errorMessages.length > 0) {
+      return errorData.errorMessages.join(', ')
+    }
+    if (Array.isArray(errorData.errors) && errorData.errors.length > 0) {
+      const err = errorData.errors[0]
+      if (err?.title) {
+        return err.detail ? `${err.title}: ${err.detail}` : err.title
+      }
+    }
+    if (errorData.errors && !Array.isArray(errorData.errors)) {
+      const fieldErrors = Object.entries(errorData.errors)
+        .map(([field, msg]) => `${field}: ${msg}`)
+        .join(', ')
+      if (fieldErrors) return fieldErrors
+    }
+    if (errorData.message) {
+      return errorData.message
+    }
+  } catch {
+    if (errorText) {
+      return errorText
+    }
+  }
+  return `${status} ${statusText}`
+}