Local File Uploads

import { open, stat } from "node:fs/promises";
import { basename } from "node:path";
import { createInterface } from "node:readline/promises";

const API_ORIGIN = "https://api.mediacaption.io";
const API_KEY = process.env.MEDIACAPTION_API_KEY;
const filePath = process.argv[2];
const estimatedDurationSec = Number.parseInt(process.argv[3] ?? "", 10);
const contentType = process.argv[4] ?? "video/mp4";

if (
  !API_KEY ||
  !filePath ||
  !Number.isInteger(estimatedDurationSec) ||
  estimatedDurationSec <= 0
) {
  throw new Error(
    "Usage: MEDIACAPTION_API_KEY=mc_live_xxx npx tsx upload.ts <file> <estimated-duration-seconds> [content-type]",
  );
}

function apiUrl(path: string) {
  return new URL(path, API_ORIGIN).toString();
}

async function apiRequest<T>(path: string, init: RequestInit = {}) {
  const response = await fetch(apiUrl(path), {
    ...init,
    headers: {
      Authorization: "Bearer " + API_KEY,
      ...(init.body ? { "Content-Type": "application/json" } : {}),
      ...init.headers,
    },
  });
  const body = await response.json();
  if (!response.ok) {
    throw new Error(response.status + " " + JSON.stringify(body));
  }
  return body as T;
}

async function readPart(
  file: Awaited<ReturnType<typeof open>>,
  offset: number,
  length: number,
) {
  const buffer = Buffer.allocUnsafe(length);
  let filled = 0;
  while (filled < length) {
    const { bytesRead } = await file.read(
      buffer,
      filled,
      length - filled,
      offset + filled,
    );
    if (bytesRead === 0) throw new Error("Unexpected end of file");
    filled += bytesRead;
  }
  return buffer;
}

type UploadCreated = {
  id: string;
  minPartSizeBytes: number;
  partUrl: string;
  completeUrl: string;
  statusUrl: string;
};

type UploadStatus = {
  status:
    | "initiated"
    | "uploading"
    | "uploaded"
    | "processing"
    | "awaiting_credits"
    | "completed"
    | "failed"
    | "aborted";
  error?: string | null;
  transcriptionUrl?: string;
};

const fileInfo = await stat(filePath);
if (fileInfo.size > 3_000_000_000) {
  throw new Error("The file exceeds the 3 GB limit");
}

// 1. Reserve credits and create the multipart upload.
const upload = await apiRequest<UploadCreated>("/v1/uploads", {
  method: "POST",
  body: JSON.stringify({
    filename: basename(filePath),
    contentType,
    sizeBytes: fileInfo.size,
    durationSec: estimatedDurationSec,
  }),
});

const uploadedParts: Array<{ partNumber: number; etag: string }> = [];
let submittedForTranscription = false;

try {
  // Every non-final part must be at least minPartSizeBytes. This example uses
  // 16 MiB and requests each 15-minute signed URL immediately before using it.
  const partSize = Math.max(upload.minPartSizeBytes, 16 * 1024 * 1024);
  const partCount = Math.ceil(fileInfo.size / partSize);
  const file = await open(filePath, "r");

  try {
    for (let index = 0; index < partCount; index += 1) {
      const partNumber = index + 1;
      const offset = index * partSize;
      const length = Math.min(partSize, fileInfo.size - offset);
      const part = await readPart(file, offset, length);

      // 2. Get a signed URL for this part from Media Caption.
      const signed = await apiRequest<{
        partNumber: number;
        uploadUrl: string;
      }>(upload.partUrl, {
        method: "POST",
        body: JSON.stringify({ partNumber }),
      });

      // 3. Upload directly to S3. Do not send the Media Caption API key here.
      const partResponse = await fetch(signed.uploadUrl, {
        method: "PUT",
        headers: { "Content-Length": String(length) },
        body: part,
      });
      if (!partResponse.ok) {
        throw new Error("Part " + partNumber + " failed: " + partResponse.status);
      }

      const etag = partResponse.headers.get("etag");
      if (!etag) throw new Error("S3 did not return an ETag");
      uploadedParts.push({ partNumber, etag });
    }
  } finally {
    await file.close();
  }

  // 4. Complete the multipart upload and start ElevenLabs transcription.
  await apiRequest(upload.completeUrl, {
    method: "POST",
    body: JSON.stringify({ parts: uploadedParts }),
  });
  submittedForTranscription = true;
} catch (error) {
  // Cancellation aborts the multipart upload and refunds reserved credits.
  if (!submittedForTranscription) {
    await fetch(apiUrl(upload.statusUrl), {
      method: "DELETE",
      headers: { Authorization: "Bearer " + API_KEY },
    });
  }
  throw error;
}

// 5. Poll until the transcript is ready. If the measured duration costs more
// than the estimate, top up the account and resume the same upload.
for (;;) {
  const status = await apiRequest<UploadStatus>(upload.statusUrl);

  if (status.status === "awaiting_credits") {
    const prompt = createInterface({ input: process.stdin, output: process.stdout });
    await prompt.question(
      "Top up credits in the dashboard, then press Enter to resume...",
    );
    prompt.close();
    await apiRequest(upload.statusUrl + "/resume", { method: "POST" });
  } else if (status.status === "completed") {
    if (!status.transcriptionUrl) {
      throw new Error("Completed upload did not return a transcription URL");
    }
    const transcription = await apiRequest(status.transcriptionUrl);
    console.log(JSON.stringify(transcription, null, 2));
    break;
  } else if (status.status === "failed" || status.status === "aborted") {
    throw new Error(status.error ?? "Upload " + status.status);
  }

  await new Promise((resolve) => setTimeout(resolve, 2_000));
}