story-research-zapwall/lib/nip95.ts

import type { MediaRef } from '@/types/nostr'
import { getEnabledNip95Apis } from './config'
import { generateNip98Token, isNip98Available } from './nip98'
import { nostrService } from './nostr'
import { nostrAuthService } from './nostrAuth'

const MAX_IMAGE_BYTES = 5 * 1024 * 1024
const MAX_VIDEO_BYTES = 45 * 1024 * 1024
const IMAGE_TYPES = ['image/png', 'image/jpeg', 'image/jpg', 'image/webp']
const VIDEO_TYPES = ['video/mp4', 'video/webm', 'video/quicktime']

interface UnlockRequiredError extends Error {
  unlockRequired: true
}

function createUnlockRequiredError(): UnlockRequiredError {
  const error = Object.assign(new Error('UNLOCK_REQUIRED'), { unlockRequired: true as const })
  return error
}

function isUnlockRequiredError(error: Error): error is UnlockRequiredError {
  return (error as Partial<UnlockRequiredError>).unlockRequired === true
}

function assertBrowser(): void {
  if (typeof window === 'undefined') {
    throw new Error('NIP-95 upload is only available in the browser')
  }
}

function validateFile(file: File): MediaRef['type'] {
  if (IMAGE_TYPES.includes(file.type)) {
    if (file.size > MAX_IMAGE_BYTES) {
      throw new Error('Image exceeds 5MB limit')
    }
    return 'image'
  }
  if (VIDEO_TYPES.includes(file.type)) {
    if (file.size > MAX_VIDEO_BYTES) {
      throw new Error('Video exceeds 45MB limit')
    }
    return 'video'
  }
  throw new Error('Unsupported media type')
}

/**
 * Parse upload response from different NIP-95 providers
 * Supports multiple formats:
 * - Standard format: { url: string }
 * - void.cat format: { ok: true, file: { id, url } }
 * - nostrcheck.me format: { url: string } or { status: 'success', url: string }
 */
function parseUploadResponse(result: unknown, endpoint: string): string {
  if (typeof result !== 'object' || result === null) {
    throw new Error('Invalid upload response format')
  }

  const obj = result as Record<string, unknown>

  // void.cat format: { ok: true, file: { id, url } }
  if ('ok' in obj && obj.ok === true && 'file' in obj) {
    const file = obj.file as Record<string, unknown>
    if (typeof file.url === 'string') {
      return file.url
    }
  }

  // nostrcheck.me format: { status: 'success', url: string }
  if ('status' in obj && obj.status === 'success' && 'url' in obj && typeof obj.url === 'string') {
    return obj.url
  }

  // Standard format: { url: string }
  if ('url' in obj && typeof obj.url === 'string') {
    return obj.url
  }

  console.error('NIP-95 upload missing URL:', {
    endpoint,
    response: result,
  })
  throw new Error('Upload response missing URL')
}

/**
 * Try uploading to a single endpoint
 * Uses proxy API route for endpoints that have CORS issues
 */
async function tryUploadEndpoint(endpoint: string, formData: FormData, useProxy: boolean = false): Promise<string> {
  const targetUrl = useProxy ? endpoint : endpoint

  const response = await globalThis.fetch(targetUrl, {
    method: 'POST',
    body: formData,
    // Don't set Content-Type manually - browser will set it with boundary automatically
  })

  if (!response.ok) {
    let errorMessage = 'Upload failed'
    try {
      const text = await response.text()
      errorMessage = text ?? `HTTP ${response.status} ${response.statusText}`
    } catch {
      errorMessage = `HTTP ${response.status} ${response.statusText}`
    }
    throw new Error(errorMessage)
  }

  let result: unknown
  try {
    result = await response.json()
  } catch (e) {
    const errorMessage = e instanceof Error ? e.message : 'Invalid JSON response'
    throw new Error(`Invalid upload response: ${errorMessage}`)
  }

  return parseUploadResponse(result, endpoint)
}

/**
 * Upload media via NIP-95.
 * Tries all enabled endpoints in order until one succeeds.
 * This implementation validates size/type then delegates to a pluggable uploader.
 */
export async function uploadNip95Media(file: File): Promise<MediaRef> {
  assertBrowser()
  const mediaType = validateFile(file)

  const endpoints = await getEnabledNip95Apis()
  if (endpoints.length === 0) {
    throw new Error(
      'NIP-95 upload endpoint is not configured. Please configure a NIP-95 API endpoint in the application settings.'
    )
  }

  const formData = new FormData()
  formData.append('file', file)

  let lastError: Error | null = null
  for (const endpoint of endpoints) {
    try {
      // Check if endpoint requires NIP-98 authentication (nostrcheck.me)
      const needsAuth = endpoint.includes('nostrcheck.me')
      let authToken: string | undefined

      if (needsAuth) {
        if (!isNip98Available()) {
          const pubkey = nostrService.getPublicKey()
          const isUnlocked = nostrAuthService.isUnlocked()
          if (!pubkey) {
            console.warn('NIP-98 authentication required for nostrcheck.me but no account found. Please create or import an account.')
            // Skip this endpoint
          } else if (!isUnlocked) {
            // Throw a special error that can be caught to trigger unlock modal
            // This error should propagate to the caller, not be caught here
            throw createUnlockRequiredError()
          } else {
            console.warn('NIP-98 authentication required for nostrcheck.me but not available. Skipping endpoint.')
            // Skip this endpoint
          }
        } else {
          try {
            // Generate NIP-98 token for the actual endpoint (not the proxy)
            // The token must be for the final destination URL
            authToken = await generateNip98Token('POST', endpoint)
          } catch (authError) {
            console.error('Failed to generate NIP-98 token:', authError)
            // Skip this endpoint if auth fails
          }
        }
      }

      // Only proceed if we have auth token when needed, or if auth is not needed
      if (!needsAuth || authToken) {
        // Always use proxy to avoid CORS, 405, and name resolution issues
        // Pass endpoint and auth token as query parameters to proxy
        const proxyUrlParams = new URLSearchParams({
          endpoint,
        })
        if (authToken) {
          proxyUrlParams.set('auth', authToken)
        }
        const proxyUrl = `/api/nip95-upload?${proxyUrlParams.toString()}`
        const url = await tryUploadEndpoint(proxyUrl, formData, true)
        return { url, type: mediaType }
      }
    } catch (e) {
      const error = e instanceof Error ? e : new Error(String(e))
      const errorMessage = error.message

      // If unlock is required, propagate the error immediately
      if (errorMessage === 'UNLOCK_REQUIRED' || isUnlockRequiredError(error)) {
        throw error
      }

      console.error('NIP-95 upload endpoint error:', {
        endpoint,
        error: errorMessage,
        fileSize: file.size,
        fileType: file.type,
      })
      lastError = error
      // Continue to next endpoint
    }
  }

  // All endpoints failed
  if (lastError) {
    throw new Error(`Failed to upload to all endpoints: ${lastError.message}`)
  }
  throw new Error('Failed to upload: no endpoints available')
}