Upload a File

// Node.js 18 or later. Save as upload.mjs, then run:
//   CLOUDFILES_API_KEY=... node upload.mjs report.pdf          a new upload
//   node upload.mjs report.pdf "$SAVED_UPLOAD_URL"              resume one
import { open, stat } from 'node:fs/promises';
import { basename } from 'node:path';

const API = 'https://api.cloudfiles.io';
const sleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));

// One request to the upload URL. A network error, 429 or 5xx is sent again,
// after Retry-After when the answer has one. Never use this for the create.
async function call(url, init = {}) {
  for (let attempt = 1; ; attempt++) {
    try {
      const res = await fetch(url, init);
      const text = await res.text();
      const result = { status: res.status, body: text ? JSON.parse(text) : {} };
      if ((res.status !== 429 && res.status < 500) || attempt === 6) return result;
      await sleep(Number(res.headers.get('retry-after')) || 2 ** attempt);
    } catch (networkError) {
      if (attempt === 6) throw networkError;
      await sleep(2 ** attempt);
    }
  }
}

function ok({ status, body }) {
  if (status >= 200 && status < 300) return body;
  throw new Error(`${status} ${body.errorCode}: ${body.message}`);
}

// Sends the missing pieces in order until the upload answers with the file.
// `upload` is the create answer, or the answer to a GET on the upload URL.
async function sendPieces(path, uploadUrl, upload) {
  const file = await open(path, 'r');
  try {
    while (!upload.file) { // a 200 or 201 carrying `file` means done
      if (upload.status === 'aborted' || upload.status === 'expired') {
        throw new Error(`The upload is ${upload.status}: create a new one`);
      }
      const [next] = upload.nextExpectedRanges;
      if (!next) { // every piece is in and the file is being put together
        await sleep(2);
        upload = ok(await call(uploadUrl));
        continue;
      }
      const start = Number(next.split('-')[0]);
      const piece = Buffer.alloc(Math.min(upload.chunkSize, upload.size - start));
      await file.read(piece, 0, piece.length, start);
      const res = await call(uploadUrl, {
        method: 'PUT',
        headers: { 'Content-Range': `bytes ${start}-${start + piece.length - 1}/${upload.size}` },
        body: piece, // a Buffer, so fetch sets Content-Length
      });
      upload = res.body.errorCode === 'UPLOAD/OUT_OF_ORDER'
        ? ok(await call(uploadUrl)) // re-read the upload, then carry on
        : ok(res);
    }
    return upload.file;
  } finally {
    await file.close();
  }
}

async function uploadFile(path, destination) {
  const { size } = await stat(path);
  // Sent once, never retried: repeating a create can leave a second upload open.
  const res = await fetch(`${API}/v1/uploads`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.CLOUDFILES_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ ...destination, name: basename(path), size }),
  });
  const upload = ok({ status: res.status, body: await res.json().catch(() => ({})) });
  // Save upload.uploadUrl somewhere safe: it is how you resume after a restart.
  return sendPieces(path, upload.uploadUrl, upload);
}

const [path, savedUploadUrl] = process.argv.slice(2);
const file = savedUploadUrl // to resume, GET the upload URL and carry on from there
  ? await sendPieces(path, savedUploadUrl, ok(await call(savedUploadUrl)))
  : await uploadFile(path, { library: 's3', folderPath: 'Contracts/2026' });
console.log('Uploaded', file.id, file.fullName);

# Python 3.8 or later with requests (pip install requests). Run:
#   CLOUDFILES_API_KEY=... python upload.py report.pdf          a new upload
#   python upload.py report.pdf "$SAVED_UPLOAD_URL"              resume one
import os
import sys
import time

import requests

API = "https://api.cloudfiles.io"


def call(method, url, **kwargs):
    # One request to the upload URL. A network error, 429 or 5xx is sent again,
    # after Retry-After when the answer has one. Never use this for the create.
    for attempt in range(1, 7):
        try:
            res = requests.request(method, url, timeout=(10, 900), **kwargs)
        except (requests.ConnectionError, requests.Timeout):
            if attempt == 6:
                raise
            time.sleep(2 ** attempt)
            continue
        if (res.status_code == 429 or res.status_code >= 500) and attempt < 6:
            wait = res.headers.get("Retry-After", "")
            time.sleep(int(wait) if wait.isdigit() else 2 ** attempt)
            continue
        return res


def body_of(res):
    try:
        return res.json()
    except ValueError:
        return {}


def ok(res):
    body = body_of(res)
    if 200 <= res.status_code < 300:
        return body
    raise RuntimeError(f"{res.status_code} {body.get('errorCode')}: {body.get('message')}")


def send_pieces(path, upload_url, upload):
    # Sends the missing pieces in order until the upload answers with the file.
    # `upload` is the create answer, or the answer to a GET on the upload URL.
    with open(path, "rb") as f:
        while "file" not in upload:  # a 200 or 201 carrying "file" means done
            if upload["status"] in ("aborted", "expired"):
                raise RuntimeError(f"The upload is {upload['status']}: create a new one")
            if not upload["nextExpectedRanges"]:
                time.sleep(2)  # every piece is in and the file is being put together
                upload = ok(call("GET", upload_url))
                continue
            start = int(upload["nextExpectedRanges"][0].split("-")[0])
            f.seek(start)
            piece = f.read(upload["chunkSize"])
            content_range = f"bytes {start}-{start + len(piece) - 1}/{upload['size']}"
            res = call("PUT", upload_url, data=piece, headers={"Content-Range": content_range})
            if body_of(res).get("errorCode") == "UPLOAD/OUT_OF_ORDER":
                upload = ok(call("GET", upload_url))  # re-read the upload, then carry on
            else:
                upload = ok(res)
    return upload["file"]


def upload_file(path, **destination):
    # Sent once, never retried: repeating a create can leave a second upload open.
    upload = ok(requests.post(
        f"{API}/v1/uploads", timeout=(10, 300),
        headers={"Authorization": f"Bearer {os.environ['CLOUDFILES_API_KEY']}"},
        json={**destination, "name": os.path.basename(path), "size": os.path.getsize(path)},
    ))
    # Save upload["uploadUrl"] somewhere safe: it is how you resume after a restart.
    return send_pieces(path, upload["uploadUrl"], upload)


if __name__ == "__main__":
    if len(sys.argv) > 2:  # to resume, GET the upload URL and carry on from there
        uploaded = send_pieces(sys.argv[1], sys.argv[2], ok(call("GET", sys.argv[2])))
    else:
        uploaded = upload_file(sys.argv[1], library="s3", folderPath="Contracts/2026")
    print("Uploaded", uploaded["id"], uploaded["fullName"])