Find and Transfer Files Across Multiple Devices from One Place

import os
import requests

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com").rstrip("/")
TOKEN = os.environ["INNORIX_ACCESS_TOKEN"]
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")   # optional; falls back to the current workspace

STATUS_COMPLETE = 2
TERMINAL = {2, 4, 5, 9, 99}          # complete / error / cancelled / partial / failed
NOT_SUCCEEDED = {4, 5, 9, 99}


def api(method, path, body=None, params=None):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    }

    if WORKSPACE_ID:
        headers["x-workspace-id"] = WORKSPACE_ID

    response = requests.request(
        method, BASE_URL + path,
        headers=headers, json=body, params=params, timeout=30,
    )

    payload = response.json() if response.content else {}

    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")

    return payload.get("data")


def is_terminal(detail):
    return detail.get("isTerminal", detail.get("status") in TERMINAL)

// InnorixClient.java
public static final String BASE_URL =
        env("INNORIX_BASE_URL", "https://app.innorix.com").replaceAll("/+
quot;, "");
public static final String WORKSPACE_ID = env("INNORIX_WORKSPACE_ID", null);

public static final int STATUS_COMPLETE = 2;
// States the transfer no longer moves out of
public static final Set<Integer> TERMINAL = Set.of(2, 4, 5, 9, 99);
// Terminal states that are not a full success
public static final Set<Integer> NOT_SUCCEEDED = Set.of(4, 5, 9, 99);

private HttpRequest.Builder headers(HttpRequest.Builder builder) {
    builder.header("Content-Type", "application/json")
           .header("Authorization", "Bearer " + session.accessToken());

    // When omitted the account's current workspace is used.
    if (workspaceId != null) builder.header("x-workspace-id", workspaceId);

    return builder;
}

/** Unwraps and returns data from the response. Throws ApiError on failure. */
public Object api(String method, String path, Object body, Map<String, Object> params) {
    Resp response = request(method, path, body, params);
    Object payload = null;

    try {
        payload = Json.parse(response.text());
    } catch (RuntimeException ignored) {
        payload = null;
    }

    if (!response.ok()) {
        Map<String, Object> map = Json.asObj(payload);
        String message = Json.str(map, "message", Json.str(map, "error", "unknown error"));
        throw new ApiError(response.status, message, map);
    }

    return Json.get(payload, "data");
}

/** Use the server flag when present, otherwise fall back to the status code. */
public static boolean isTerminal(Map<String, Object> record) {
    Boolean flag = Json.boolOrNull(record, "isTerminal");
    if (flag != null) return flag;

    Integer status = Json.intOrNull(record, "status");
    return status != null && TERMINAL.contains(status);
}

// innorix-client.js
const BASE_URL = (process.env.INNORIX_BASE_URL
  || "https://app.innorix.com").replace(/\/+$/, "");
const TOKEN = process.env.INNORIX_ACCESS_TOKEN;
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID || null;

export const STATUS_COMPLETE = 2;
export const TERMINAL = new Set([2, 4, 5, 9, 99]);       // complete / error / cancelled / partial / failed
export const NOT_SUCCEEDED = new Set([4, 5, 9, 99]);

export async function api(method, path, body = null, params = null) {
  const url = new URL(BASE_URL + path);

  if (params) {
    for (const [key, value] of Object.entries(params)) {
      if (value === undefined || value === null) continue;
      url.searchParams.set(key, String(value));
    }
  }

  const headers = {
    "Content-Type": "application/json",
    Authorization: `Bearer ${TOKEN}`,
  };

  // When omitted the account's current workspace is used.
  if (WORKSPACE_ID) headers["x-workspace-id"] = WORKSPACE_ID;

  const response = await fetch(url, {
    method,
    headers,
    body: body === null ? undefined : JSON.stringify(body),
    signal: AbortSignal.timeout(30_000),
  });

  const payload = await response.json().catch(() => ({}));

  if (!response.ok) {
    throw new Error(payload.message || `HTTP ${response.status}`);
  }

  return payload.data;
}

export function isTerminal(detail) {
  return detail.isTerminal !== undefined
    ? detail.isTerminal
    : TERMINAL.has(detail.status);
}

// InnorixClient.cs
public static readonly string BaseUrl =
    Env("INNORIX_BASE_URL", "https://app.innorix.com").TrimEnd('/');
public static readonly string WorkspaceIdFromEnv = Env("INNORIX_WORKSPACE_ID", null);

public const int StatusComplete = 2;
/// <summary>States the transfer no longer moves out of</summary>
public static readonly HashSet<int> Terminal = new HashSet<int> { 2, 4, 5, 9, 99 };
/// <summary>Terminal states that are not a full success</summary>
public static readonly HashSet<int> NotSucceeded = new HashSet<int> { 4, 5, 9, 99 };

// Applied on every request
request.Headers.TryAddWithoutValidation("Authorization", "Bearer " + Session.AccessToken);
// When omitted the account's current workspace is used.
if (WorkspaceId != null) request.Headers.TryAddWithoutValidation("x-workspace-id", WorkspaceId);

public async Task<JsonNode> ApiAsync(string method, string path, JsonNode body = null,
    IDictionary<string, object> parameters = null)
{
    Resp response = await RequestAsync(method, path, body, parameters).ConfigureAwait(false);
    JsonNode payload = null;

    try
    {
        payload = J.Parse(response.Text());
    }
    catch (Exception)
    {
        payload = null;
    }

    if (!response.Ok)
    {
        JsonObject map = J.AsObj(payload);
        string message = J.Str(map, "message", J.Str(map, "error", "unknown error"));
        throw new ApiError(response.Status, message, map);
    }

    return J.Get(payload, "data");
}

/// <summary>Use the server flag when present, otherwise fall back to the status code.</summary>
public static bool IsTerminal(JsonObject record)
{
    bool? flag = J.BoolOrNull(record, "isTerminal");
    if (flag != null) return flag.Value;

    int? status = J.IntOrNull(record, "status");
    return status != null && Terminal.Contains(status.Value);
}

result = api("GET", f"/api/devices/{device_id}/files", params={
    "path": "/data/reports",
    "page": 1,
    "size": 50,
    "sort": "name:asc",
    "type": "all",
})

for item in result["items"]:
    kind = "DIR " if item["isDir"] else "FILE"
    print(kind, item["name"], item["size"], item.get("modifiedAt"))

Map<String, Object> params = Json.newObj(
        "path", "/data/reports",
        "page", 1,
        "size", 50,
        "sort", "name:asc",
        "type", "all");

Map<String, Object> result = client.apiObj("GET", "/api/devices/" + deviceId + "/files", null, params);

for (Object item : Json.arrOf(result, "items")) {
    Map<String, Object> file = Json.asObj(item);
    String kind = Json.bool(file, "isDir", false) ? "DIR " : "FILE";
    System.out.println(kind + " " + Json.str(file, "name") + " " + Json.str(file, "size"));
}

const result = await client.api("GET", `/api/devices/${deviceId}/files`, null, {
  path: "/data/reports",
  page: 1,
  size: 50,
  sort: "name:asc",
  type: "all",
});

for (const item of result.items) {
  const kind = item.isDir ? "DIR " : "FILE";
  console.log(kind, item.name, item.size, item.modifiedAt);
}

var parameters = new Dictionary<string, object>
{
    ["path"] = "/data/reports",
    ["page"] = 1,
    ["size"] = 50,
    ["sort"] = "name:asc",
    ["type"] = "all",
};

JsonObject result = await client.ApiObjAsync(
    "GET", "/api/devices/" + deviceId + "/files", null, parameters);

foreach (JsonNode item in J.ArrOf(result, "items"))
{
    JsonObject file = J.AsObj(item);
    string kind = J.Bool(file, "isDir", false) ? "DIR " : "FILE";
    Console.WriteLine(
quot;{kind} {J.Str(file, "name")} {J.Str(file, "size")}");
}

result = api("GET", "/api/devices", params={"page": 1, "size": 200})

for device in result["devices"]:
    print(device["deviceId"], device["name"], device.get("os"),
          device.get("ipAddress"))

Map<String, Object> result = client.apiObj("GET", "/api/devices", null,
        Json.newObj("page", 1, "size", 200));

for (Object item : Json.arrOf(result, "devices")) {
    Map<String, Object> device = Json.asObj(item);
    System.out.println(Json.str(device, "deviceId") + " " + Json.str(device, "name")
            + " " + Json.str(device, "os") + " " + Json.str(device, "ipAddress"));
}

const result = await client.api("GET", "/api/devices", null, { page: 1, size: 200 });

for (const device of result.devices) {
  console.log(device.deviceId, device.name, device.os, device.ipAddress);
}

JsonObject result = await client.ApiObjAsync("GET", "/api/devices", null,
    new Dictionary<string, object> { ["page"] = 1, ["size"] = 200 });

foreach (JsonNode item in J.ArrOf(result, "devices"))
{
    JsonObject device = J.AsObj(item);
    Console.WriteLine(
quot;{J.Str(device, "deviceId")} {J.Str(device, "name")} "
        + 
quot;{J.Str(device, "os")} {J.Str(device, "ipAddress")}");
}

RESTART_CODES = {"INVALID_CURSOR", "CURSOR_OUT_OF_SEQUENCE", "SEARCH_EXPIRED"}


def start_search(device_id, path, page_size=500):
    return api("POST", f"/api/devices/{device_id}/files/search",
               {"path": path, "pageSize": page_size})


def iter_search(device_id, path, max_pages=200):
    page = start_search(device_id, path)
    search_id = page.get("searchId")

    for _ in range(max_pages):
        for item in page.get("items") or []:
            yield search_id, item

        if not page.get("hasMore"):
            return

        try:
            page = api("GET", f"/api/devices/{device_id}/files/search",
                       params={"cursor": page["nextCursor"]})
        except RuntimeError:
            # restart the scan when the cursor expires or falls out of sequence
            page = start_search(device_id, path)
            search_id = page.get("searchId")

static final Set<String> RESTART_CODES =
        Set.of("INVALID_CURSOR", "CURSOR_OUT_OF_SEQUENCE", "SEARCH_EXPIRED");

Map<String, Object> startSearch(String deviceId, String path, int pageSize) {
    return client.apiObj("POST", "/api/devices/" + deviceId + "/files/search",
            Json.newObj("path", path, "pageSize", pageSize));
}

List<Map<String, Object>> search(String deviceId, String path, int maxPages) {
    List<Map<String, Object>> found = new ArrayList<>();
    Map<String, Object> page = startSearch(deviceId, path, 500);

    for (int i = 0; i < maxPages; i++) {
        for (Object item : Json.arrOf(page, "items")) found.add(Json.asObj(item));

        if (!Json.bool(page, "hasMore", false)) return found;

        try {
            page = client.apiObj("GET", "/api/devices/" + deviceId + "/files/search",
                    null, Json.newObj("cursor", Json.str(page, "nextCursor")));
        } catch (InnorixClient.ApiError error) {
            // Restart the scan when the cursor expires or falls out of sequence.
            if (!RESTART_CODES.contains(Json.str(error.payload(), "error"))) throw error;
            page = startSearch(deviceId, path, 500);
        }
    }

    return found;
}

const RESTART_CODES = new Set([
  "INVALID_CURSOR", "CURSOR_OUT_OF_SEQUENCE", "SEARCH_EXPIRED",
]);

async function startSearch(deviceId, path, pageSize = 500) {
  return client.api("POST", `/api/devices/${deviceId}/files/search`,
    { path, pageSize });
}

async function* iterSearch(deviceId, path, maxPages = 200) {
  let page = await startSearch(deviceId, path);
  let searchId = page.searchId;

  for (let i = 0; i < maxPages; i += 1) {
    for (const item of page.items || []) yield [searchId, item];

    if (!page.hasMore) return;

    try {
      page = await client.api("GET", `/api/devices/${deviceId}/files/search`,
        null, { cursor: page.nextCursor });
    } catch (error) {
      // Restart the scan when the cursor expires or falls out of sequence.
      if (!RESTART_CODES.has(error.payload?.error)) throw error;
      page = await startSearch(deviceId, path);
      searchId = page.searchId;
    }
  }
}

static readonly HashSet<string> RestartCodes = new HashSet<string>
{
    "INVALID_CURSOR", "CURSOR_OUT_OF_SEQUENCE", "SEARCH_EXPIRED",
};

async Task<JsonObject> StartSearchAsync(string deviceId, string path, int pageSize = 500)
{
    return await client.ApiObjAsync("POST", 
quot;/api/devices/{deviceId}/files/search",
        new JsonObject { ["path"] = path, ["pageSize"] = pageSize });
}

async Task<List<JsonObject>> SearchAsync(string deviceId, string path, int maxPages = 200)
{
    var found = new List<JsonObject>();
    JsonObject page = await StartSearchAsync(deviceId, path);

    for (int i = 0; i < maxPages; i++)
    {
        foreach (JsonNode item in J.ArrOf(page, "items")) found.Add(J.AsObj(item));

        if (!J.Bool(page, "hasMore", false)) return found;

        try
        {
            page = await client.ApiObjAsync("GET", 
quot;/api/devices/{deviceId}/files/search",
                null, new Dictionary<string, object> { ["cursor"] = J.Str(page, "nextCursor") });
        }
        catch (InnorixClient.ApiError error)
        {
            // Restart the scan when the cursor expires or falls out of sequence.
            if (!RestartCodes.Contains(J.Str(error.Payload, "error"))) throw;
            page = await StartSearchAsync(deviceId, path);
        }
    }

    return found;
}

def cancel_search(device_id, search_id):
    api("POST", f"/api/devices/{device_id}/files/search/cancel",
        {"uuid": search_id})       # pass the searchId returned when the search started


search_id = None

try:
    for search_id, item in iter_search(device_id, "/data"):
        if item["type"] == "file" and item["name"].endswith(".csv"):
            print(item["path"], item["size"])
finally:
    if search_id:
        cancel_search(device_id, search_id)

void cancelSearch(String deviceId, String searchId) {
    // pass the searchId returned when the search started
    client.api("POST", "/api/devices/" + deviceId + "/files/search/cancel",
            Json.newObj("uuid", searchId));
}

String searchId = null;

try {
    Map<String, Object> page = startSearch(deviceId, "/data", 500);
    searchId = Json.str(page, "searchId");
    // ... walk the results
} finally {
    if (searchId != null) cancelSearch(deviceId, searchId);
}

async function cancelSearch(deviceId, searchId) {
  // pass the searchId returned when the search started
  await client.api("POST", `/api/devices/${deviceId}/files/search/cancel`,
    { uuid: searchId });
}

let searchId = null;

try {
  for await (const [id, item] of iterSearch(deviceId, "/data")) {
    searchId = id;
    if (item.type === "file" && item.name.endsWith(".csv")) {
      console.log(item.path, item.size);
    }
  }
} finally {
  if (searchId) await cancelSearch(deviceId, searchId);
}

async Task CancelSearchAsync(string deviceId, string searchId)
{
    // pass the searchId returned when the search started
    await client.ApiAsync("POST", 
quot;/api/devices/{deviceId}/files/search/cancel",
        new JsonObject { ["uuid"] = searchId });
}

string searchId = null;

try
{
    JsonObject page = await StartSearchAsync(deviceId, "/data");
    searchId = J.Str(page, "searchId");
    // ... walk the results
}
finally
{
    if (searchId != null) await CancelSearchAsync(deviceId, searchId);
}

def send_files(source, target, target_path, paths, action="numbering"):
    transfer = api("POST", "/api/transfers/manual", {
        "sourceDevice": source,
        "targetDevice": target,
        "targetPath": target_path,
        "sourceItem": [{"path": p, "isDir": False} for p in paths],
        "sendAllFolder": False,
        "transferOptions": {"target-action": action},
    })

    return transfer["monitorId"]


monitor_id = send_files("device-a", "device-b", "/data/collected",
                        ["/data/reports/2026-08.csv"])

String sendFiles(String source, String target, String targetPath,
                 List<String> paths, String action) {
    List<Object> items = new ArrayList<>();
    for (String path : paths) items.add(Json.newObj("path", path, "isDir", false));

    Map<String, Object> transfer = client.apiObj("POST", "/api/transfers/manual", Json.newObj(
            "sourceDevice", source,
            "targetDevice", target,
            "targetPath", targetPath,
            "sourceItem", items,
            "sendAllFolder", false,
            "transferOptions", Json.newObj("target-action", action)));

    return Json.str(transfer, "monitorId");
}

String monitorId = sendFiles("device-a", "device-b", "/data/collected",
        List.of("/data/reports/2026-08.csv"), "numbering");

async function sendFiles(source, target, targetPath, paths, action = "numbering") {
  const transfer = await client.api("POST", "/api/transfers/manual", {
    sourceDevice: source,
    targetDevice: target,
    targetPath,
    sourceItem: paths.map((path) => ({ path, isDir: false })),
    sendAllFolder: false,
    transferOptions: { "target-action": action },
  });

  return transfer.monitorId;
}

const monitorId = await sendFiles("device-a", "device-b", "/data/collected",
  ["/data/reports/2026-08.csv"]);

async Task<string> SendFilesAsync(string source, string target, string targetPath,
    IEnumerable<string> paths, string action = "numbering")
{
    var items = new JsonArray();
    foreach (string path in paths)
        items.Add(new JsonObject { ["path"] = path, ["isDir"] = false });

    JsonObject transfer = await client.ApiObjAsync("POST", "/api/transfers/manual",
        new JsonObject
        {
            ["sourceDevice"] = source,
            ["targetDevice"] = target,
            ["targetPath"] = targetPath,
            ["sourceItem"] = items,
            ["sendAllFolder"] = false,
            ["transferOptions"] = new JsonObject { ["target-action"] = action },
        });

    return J.Str(transfer, "monitorId");
}

string monitorId = await SendFilesAsync("device-a", "device-b", "/data/collected",
    new[] { "/data/reports/2026-08.csv" });

api("POST", "/api/transfers/manual", {
    "sourceDevice": "device-a",
    "targetDevice": "device-b",
    "targetPath": "/data/collected",
    "sourcePaths": ["/data/reports"],
    "sendAllFolder": True,
    "transferOptions": {"target-action": "numbering"},
})

client.api("POST", "/api/transfers/manual", Json.newObj(
        "sourceDevice", "device-a",
        "targetDevice", "device-b",
        "targetPath", "/data/collected",
        "sourcePaths", List.of("/data/reports"),
        "sendAllFolder", true,
        "transferOptions", Json.newObj("target-action", "numbering")));

await client.api("POST", "/api/transfers/manual", {
  sourceDevice: "device-a",
  targetDevice: "device-b",
  targetPath: "/data/collected",
  sourcePaths: ["/data/reports"],
  sendAllFolder: true,
  transferOptions: { "target-action": "numbering" },
});

await client.ApiAsync("POST", "/api/transfers/manual", new JsonObject
{
    ["sourceDevice"] = "device-a",
    ["targetDevice"] = "device-b",
    ["targetPath"] = "/data/collected",
    ["sourcePaths"] = new JsonArray { "/data/reports" },
    ["sendAllFolder"] = true,
    ["transferOptions"] = new JsonObject { ["target-action"] = "numbering" },
});

"sourceItem": [
  { "path": "/data/a.csv", "isDir": false, "fileSize": 1200 }
]

import time


def wait(monitor_id, timeout=1800, interval=3):
    deadline = time.time() + timeout

    while time.time() < deadline:
        detail = api("GET", f"/api/transfers/{monitor_id}")

        if is_terminal(detail):
            return detail

        time.sleep(interval)

    raise TimeoutError(monitor_id)


detail = wait(monitor_id)
succeeded = detail["status"] == STATUS_COMPLETE

Map<String, Object> wait(String monitorId, int timeoutSeconds, int intervalSeconds) {
    long deadline = System.currentTimeMillis() + timeoutSeconds * 1000L;

    while (System.currentTimeMillis() < deadline) {
        Map<String, Object> detail = client.apiObj("GET", "/api/transfers/" + monitorId);

        if (InnorixClient.isTerminal(detail)) return detail;

        Thread.sleep(intervalSeconds * 1000L);
    }

    throw new InnorixClient.ApiError(0, "timeout waiting for " + monitorId);
}

Map<String, Object> detail = wait(monitorId, 1800, 3);
boolean succeeded = Json.intOrNull(detail, "status") != null
        && Json.intOrNull(detail, "status") == InnorixClient.STATUS_COMPLETE;

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function wait(monitorId, { timeout = 1800, interval = 3 } = {}) {
  const deadline = Date.now() + timeout * 1000;

  while (Date.now() < deadline) {
    const detail = await client.api("GET", `/api/transfers/${monitorId}`);

    if (isTerminal(detail)) return detail;

    await sleep(interval * 1000);
  }

  throw new Error(`timeout waiting for ${monitorId}`);
}

const detail = await wait(monitorId);
const succeeded = detail.status === STATUS_COMPLETE;

async Task<JsonObject> WaitAsync(string monitorId, int timeoutSeconds = 1800,
    int intervalSeconds = 3)
{
    long deadline = Environment.TickCount64 + timeoutSeconds * 1000L;

    while (Environment.TickCount64 < deadline)
    {
        JsonObject detail = await client.ApiObjAsync("GET", "/api/transfers/" + monitorId);

        if (InnorixClient.IsTerminal(detail)) return detail;

        await Task.Delay(intervalSeconds * 1000);
    }

    throw new InnorixClient.ApiError(0, "timeout waiting for " + monitorId);
}

JsonObject detail = await WaitAsync(monitorId);
bool succeeded = J.IntOrNull(detail, "status") == InnorixClient.StatusComplete;

def failed_files(monitor_id):
    result = api("GET", f"/api/transfers/{monitor_id}/files", params={
        "state": "any", "size": 500,
    }) or {}

    return [r for r in (result.get("children") or [])
            if r.get("status") in NOT_SUCCEEDED]


def retry_failed(monitor_id):
    rows = failed_files(monitor_id)

    if not rows:
        return 0

    api("POST", f"/api/transfers/{monitor_id}/retry", {
        "filesRetry": [
            {"filePath": r["sourceFilePath"], "isDir": bool(r.get("isFolder"))}
            for r in rows
        ]
    })

    return len(rows)

List<Map<String, Object>> failedFiles(String monitorId) {
    Map<String, Object> result = client.apiObj("GET",
            "/api/transfers/" + monitorId + "/files", null,
            Json.newObj("state", "any", "size", 500));

    List<Map<String, Object>> failed = new ArrayList<>();

    for (Object item : Json.arrOf(result, "children")) {
        Map<String, Object> row = Json.asObj(item);
        Integer status = Json.intOrNull(row, "status");
        if (status != null && InnorixClient.NOT_SUCCEEDED.contains(status)) failed.add(row);
    }

    return failed;
}

int retryFailed(String monitorId) {
    List<Map<String, Object>> rows = failedFiles(monitorId);
    if (rows.isEmpty()) return 0;

    List<Object> filesRetry = new ArrayList<>();

    for (Map<String, Object> row : rows) {
        filesRetry.add(Json.newObj(
                "filePath", Json.str(row, "sourceFilePath"),
                "isDir", Json.bool(row, "isFolder", false)));
    }

    client.api("POST", "/api/transfers/" + monitorId + "/retry",
            Json.newObj("filesRetry", filesRetry));

    return rows.size();
}

async function failedFiles(monitorId) {
  const result = (await client.api("GET", `/api/transfers/${monitorId}/files`,
    null, { state: "any", size: 500 })) || {};

  return (result.children || []).filter((row) => NOT_SUCCEEDED.has(row.status));
}

async function retryFailed(monitorId) {
  const rows = await failedFiles(monitorId);

  if (rows.length === 0) return 0;

  await client.api("POST", `/api/transfers/${monitorId}/retry`, {
    filesRetry: rows.map((row) => ({
      filePath: row.sourceFilePath,
      isDir: Boolean(row.isFolder),
    })),
  });

  return rows.length;
}

async Task<List<JsonObject>> FailedFilesAsync(string monitorId)
{
    JsonObject result = await client.ApiObjAsync("GET",
        
quot;/api/transfers/{monitorId}/files", null,
        new Dictionary<string, object> { ["state"] = "any", ["size"] = 500 });

    return J.ArrOf(result, "children")
        .Select(J.AsObj)
        .Where(row =>
        {
            int? status = J.IntOrNull(row, "status");
            return status != null && InnorixClient.NotSucceeded.Contains(status.Value);
        })
        .ToList();
}

async Task<int> RetryFailedAsync(string monitorId)
{
    List<JsonObject> rows = await FailedFilesAsync(monitorId);
    if (rows.Count == 0) return 0;

    var filesRetry = new JsonArray();

    foreach (JsonObject row in rows)
    {
        filesRetry.Add(new JsonObject
        {
            ["filePath"] = J.Str(row, "sourceFilePath"),
            ["isDir"] = J.Bool(row, "isFolder", false),
        });
    }

    await client.ApiAsync("POST", 
quot;/api/transfers/{monitorId}/retry",
        new JsonObject { ["filesRetry"] = filesRetry });

    return rows.Count;
}