Import Progress

curl -N "https://vas-poc.vurbo.ai/api/v1/sse/imports/550e8400-e29b-41d4-a716-446655440000/progress" \
  -H "X-API-Key: vas_aB3dE5fG7hI9jK1lM3nO5pQ7rS9tU1vW"

// Use the fetch API (because EventSource does not support headers)
async function connectSSE(importId, apiKey) {
  const response = await fetch(
    `https://vas-poc.vurbo.ai/api/v1/sse/imports/${importId}/progress`,
    {
      headers: {
        'X-API-Key': apiKey
      }
    }
  );
  const reader = response.body.getReader();
  // ... handle SSE events
}

Scenario 1: Import still in progress
┌────────────────────────────────────────────────────┐
│ 1. connected       → Connection confirmed          │
│ 2. progress        → Send current progress          │
│ 3. progress ×N     → Pushed continuously on change  │
│    heartbeat ×N    → Sent every 15s if no change    │
│ 4. completed       → Import succeeded, connection ends │
│    or failed       → Import failed, connection ends    │
│    or timeout      → Exceeded 15 minutes, connection ends │
└────────────────────────────────────────────────────┘

Scenario 2: Import already completed (terminal state)
┌────────────────────────────────────────────────────┐
│ 1. connected       → Connection confirmed          │
│ 2. progress        → Send final progress            │
│ 3. completed       → Send completed event directly and end │
│    or failed       → Send failed event directly and end    │
└────────────────────────────────────────────────────┘

event: connected
data: {"message":"Import progress service connected (importId: 550e8400-e29b-41d4-a716-446655440000)"}

{
  "message": "Import progress service connected (importId: xxx)"
}

event: progress
data: {"import_id":"550e8400-...","status":"processing","stage":"transcribing","progress":45,"message":"Transcribing..."}

{
  "import_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "processing",
  "stage": "transcribing",
  "progress": 45,
  "message": "Transcribing..."
}

event: completed
data: {"import_id":"550e8400-...","status":"completed","task_id":"abc123-...","message":"Processing completed"}

{
  "import_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "completed",
  "task_id": "abc123-e29b-41d4-a716-446655440000",
  "message": "Processing completed"
}

event: failed
data: {"import_id":"550e8400-...","status":"failed","error_code":"import_invalid_format","error_message":"Unsupported audio format"}

{
  "import_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "failed",
  "error_code": "import_invalid_format",
  "error_message": "Unsupported audio format"
}

event: heartbeat
data: {"timestamp":1708761600}

{
  "timestamp": 1708761600
}

event: timeout
data: {"message":"Connection timed out"}

{
  "message": "Connection timed out"
}

async function trackImportProgress(importId, apiKey) {
  const response = await fetch(
    `https://vas-poc.vurbo.ai/api/v1/sse/imports/${importId}/progress`,
    {
      headers: {
        'X-API-Key': apiKey
      }
    }
  );

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let buffer = '';

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, { stream: true });

    // Parse SSE format: event: xxx\ndata: {...}\n\n
    const events = buffer.split('\n\n');
    buffer = events.pop(); // Keep the incomplete part

    for (const eventStr of events) {
      if (!eventStr.trim()) continue;

      const lines = eventStr.split('\n');
      let eventType = '';
      let eventData = '';

      for (const line of lines) {
        if (line.startsWith('event: ')) {
          eventType = line.slice(7);
        } else if (line.startsWith('data: ')) {
          eventData = line.slice(6);
        }
      }

      if (!eventType || !eventData) continue;

      const data = JSON.parse(eventData);

      switch (eventType) {
        case 'connected':
          console.log('Connected:', data.message);
          break;

        case 'progress':
          console.log(`[${data.stage}] ${data.progress}% - ${data.message}`);
          // Update the UI progress bar
          updateProgressBar(data.progress, data.stage, data.message);
          break;

        case 'completed':
          console.log('Import completed! Recording ID:', data.task_id);
          // Navigate to the recording details page
          navigateToRecording(data.task_id);
          break;

        case 'failed':
          console.error('Import failed:', data.error_code, data.error_message);
          // Show the error message
          showError(data.error_message);
          break;

        case 'heartbeat':
          console.log('Heartbeat:', new Date(data.timestamp * 1000));
          break;

        case 'timeout':
          console.warn('Connection timed out:', data.message);
          break;

        case 'error':
          console.error('Error:', data);
          break;
      }
    }
  }
}