Transfer files between systems to applications

https://app.innorix.com

{
  "status_code": 200,
  "message": "OK",
  "data": {
    "matchCount": 1,
    "devices": [
{
        "deviceId": "dev_01H8...",
        "name": "OfficePC",
        "ipAddress": "192.168.0.9",
        "osType": "windows",
        "state": 1, "stateName": "CONNECTED", "stateLabel": "Connected",
        "isConnected": true
}
]
}
}

{
  "status_code": 200,
  "message": "OK",
  "data": {
    "path": "/data", "total": 128, "page": 1, "size": 50, "lastPage": 3,
    "items": [
{
"name": "Report.pdf",
"path": "/data/report.pdf",
        "fileToken": "L2RhdGEv...",
        "isDir": false, "size": 20480,
        "modifiedAt": "2026-08-01T09:12:00Z"
}
]
}
}

{
  "sourceId": "device-source-01",
  "targetId": "device-target-01",
  "targetPath": "/data/incoming",
  "sourceItem": [{ "hash": "device-source-01_ino_L2RhdGEvcmVwb3J0LnBkZg==", "isDir": false }],
  "sendAllFolder": false
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "monitorId": "mon-abc123", "transferId": "tr-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01";
const TARGET_ID = process.env.INNORIX_TARGET_ID || "device-target-01";
const SOURCE_PATH = process.env.INNORIX_SOURCE_PATH || "/data/report.pdf";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/data/incoming";
const TRANSFER_STATUS = Object.freeze({ transferComplete: 2, transferError: 4, transferCancel: 5, transferPartialComplete: 9, transferFail: 99 });
const TERMINAL_STATUSES = new Set(Object.values(TRANSFER_STATUS));

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function waitForCompletion(monitorId, token) {
for (;;) {
        const detail = await api("GET", `/api/transfers/${monitorId}`, token);
        console.log({ monitorId, status: detail.status, percent: detail.percent || 0 });
if (detail.isTerminal ?? TERMINAL_STATUSES.has(detail.status)) {
            if (detail.status !== TRANSFER_STATUS.transferComplete) throw new Error(detail.errorCode || "Transfer failed");
return detail;
}
        await new Promise((resolve) => setTimeout(resolve, 2000));
}
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

// The item to send is specified by the hash of sourceItem.
    const sourceItem = [{ hash: encodePath(SOURCE_ID, SOURCE_PATH), isDir: false }];
    const transfer = await api("POST", "/api/transfers/manual", token, {
        sourceId: SOURCE_ID,
        targetId: TARGET_ID,
        targetPath: TARGET_PATH,
        sourceItem,
        sendAllFolder: false,
});
    console.log("transfer created", { monitorId: transfer.monitorId, status: transfer.status });

    await waitForCompletion(transfer.monitorId, token);
    console.log("Transfer completed");
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "sourceId": "dev_01H8BRANCH...",
  "targetId": "dev_01H8HQ...",
  "targetPath": "/collect/logs",
  "sourceItem": [{ "hash": "dev_01H8BRANCH..._ino_L3Zhci9sb2cvYXBwLWxvZw==", "isDir": true }],
  "sendAllFolder": true,
  "transferOptions": { "target-action": "numbering" }
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "monitorId": "mon-abc123", "transferId": "tr-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const BRANCH_DEVICES = (process.env.INNORIX_BRANCH_DEVICES || "branch-pc-01,branch-pc-02,branch-pc-03").split(",");
const HQ_DEVICE = process.env.INNORIX_HQ_DEVICE || "headquarters-server";
const SOURCE_ROOT = process.env.INNORIX_SOURCE_ROOT || "/var/log";
const SEARCH = process.env.INNORIX_LOG_FOLDER_SEARCH || "log";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/collect/logs";
async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}
async function resolveDevice(name, token) {
    const data = await api("GET", `/api/devices/resolve?name=${encodeURIComponent(name)}`, token);
if (data.matchCount !== 1) throw new Error(`Device must resolve uniquely: ${name}`);
return data.devices[0].deviceId;
}
function encodePath(deviceId, path) {
// Normalize path separators before UTF-8 Base64 encoding.
    const normalizedPath = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalizedPath, "utf8").toString("base64")}`;
}

async function main() {
Search the log folders of the three locations and create an independent transfer for each.
    const login = await api("POST", "/api/auth/login", null, {
        email: process.env.INNORIX_EMAIL,
        password: process.env.INNORIX_PASSWORD,
});
const token = login.user.accessToken;
    const targetId = await resolveDevice(HQ_DEVICE, token);
const monitorIds = new Map();
for (const rawName of BRANCH_DEVICES) {
const branchName = rawName.trim();
        const sourceId = await resolveDevice(branchName, token);
        const query = new URLSearchParams({ path: SOURCE_ROOT, type: "dir", search: SEARCH, size: "500" });
        const listing = await api("GET", `/api/devices/${sourceId}/files?${query}`, token);
if (!listing.items.length) throw new Error(`Log folder not found: ${branchName}`);
const folder = listing.items[0];
        const transfer = await api("POST", "/api/transfers/manual", token, {
            sourceId,
            targetId,
            targetPath: TARGET_PATH,
            sourceItem: [{ hash: encodePath(sourceId, folder.path), isDir: true }],
            sendAllFolder: true,
            transferOptions: { "target-action": "numbering" },
});
        monitorIds.set(branchName, transfer.monitorId);
}

// Aggregates the total completion status of parallel tasks until all monitorIds are finished.
const pending = new Map(monitorIds);
while (pending.size) {
await Promise.all(
            [...pending].map(async ([branchName, monitorId]) => {
                const detail = await api("GET", `/api/transfers/${monitorId}`, token);
console.log(`${branchName}: status=${detail.status} percent=${detail.percent || 0}`);
                if ([2, 4, 5, 9, 99].includes(detail.status)) {
                    if (detail.status !== 2) throw new Error(`${branchName}: ${detail.errorCode || "failed"}`);
pending.delete(branchName);
}
})
);
        if (pending.size) await new Promise((resolve) => setTimeout(resolve, 2000));
}
console.log(`Collected logs from ${monitorIds.size} branches`);
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "sourceId": "dev_01H8SRC...",
  "targetId": "dev_01H8BRANCH01...",
  "targetPath": "/deploy",
  "sourceItem": [{ "hash": "dev_01H8SRC..._ino_L2RlcGxveS9kZXBsb3ltZW50LXBhY2thZ2U=", "isDir": true }],
  "sendAllFolder": true,
  "transferOptions": { "target-action": "overwrite" }
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "monitorId": "mon-abc123", "transferId": "tr-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01";
const TARGET_IDS = (process.env.INNORIX_TARGET_IDS || "device-target-01,device-target-02,device-target-03").split(",");
const SOURCE_ROOT = process.env.INNORIX_SOURCE_ROOT || "/deploy";
const PACKAGE_NAME = process.env.INNORIX_PACKAGE_NAME || "deployment-package";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/deploy";
const TRANSFER_STATUS = Object.freeze({ transferComplete: 2, transferError: 4, transferCancel: 5, transferPartialComplete: 9, transferFail: 99 });
const TERMINAL_STATUSES = new Set(Object.values(TRANSFER_STATUS));

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

// Search the distribution package folder at headquarters once.
    const query = new URLSearchParams({ path: SOURCE_ROOT, type: "dir", search: PACKAGE_NAME, size: "500" });
    const listing = await api("GET", `/api/devices/${SOURCE_ID}/files?${query}`, token);
const packageFolder = listing.items.find((item) => item.name === PACKAGE_NAME);
if (!packageFolder) throw new Error(`Package folder not found: ${PACKAGE_NAME}`);
    const sourceItem = [{ hash: encodePath(SOURCE_ID, packageFolder.path), isDir: true }];

// Send the same package to multiple targets separately.
    const pending = new Map(),
results = new Map();
for (const rawId of TARGET_IDS) {
const targetId = rawId.trim();
        const transfer = await api("POST", "/api/transfers/manual", token, {
            sourceId: SOURCE_ID,
            targetId,
            targetPath: TARGET_PATH,
            sourceItem,
            sendAllFolder: true,
            transferOptions: { "target-action": "overwrite" },
});
        pending.set(targetId, transfer.monitorId);
}

// Aggregates completed targets by separating them into success and failure lists.
while (pending.size) {
await Promise.all(
            [...pending].map(async ([targetId, monitorId]) => {
                const detail = await api("GET", `/api/transfers/${monitorId}`, token);
if (detail.isTerminal ?? TERMINAL_STATUSES.has(detail.status)) {
                    results.set(targetId, detail.status === TRANSFER_STATUS.transferComplete ? "success" : detail.errorCode || "failed");
pending.delete(targetId);
}
})
);
        if (pending.size) await new Promise((resolve) => setTimeout(resolve, 2000));
}
    const succeeded = [...results].filter(([, value]) => value === "success").map(([name]) => name);
    const failed = Object.fromEntries([...results].filter(([, value]) => value !== "success"));
    console.log({ succeeded, failed });
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "sourceId": "device-src-001",
  "targetId": "device-dst-002",
  "targetPath": "/data/incoming",
  "sourceItem": [{ "hash": "device-src-001_ino_L2RhdGEvcmVwb3J0LnBkZg==", "isDir": false }]
}

{
  "status_code": 200,
  "message": "success",
  "data": { "valid": true }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01";
const TARGET_ID = process.env.INNORIX_TARGET_ID || "device-target-01";
const SOURCE_PATH = process.env.INNORIX_SOURCE_PATH || "/data/report.pdf";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/data/incoming";
const TRANSFER_STATUS = Object.freeze({ transferComplete: 2, transferError: 4, transferCancel: 5, transferPartialComplete: 9, transferFail: 99 });
const TERMINAL_STATUSES = new Set(Object.values(TRANSFER_STATUS));

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function waitForCompletion(monitorId, token) {
for (;;) {
        const detail = await api("GET", `/api/transfers/${monitorId}`, token);
        console.log({ monitorId, status: detail.status, percent: detail.percent || 0 });
if (detail.isTerminal ?? TERMINAL_STATUSES.has(detail.status)) {
            if (detail.status !== TRANSFER_STATUS.transferComplete) throw new Error(detail.errorCode || "Transfer failed");
return detail;
}
        await new Promise((resolve) => setTimeout(resolve, 2000));
}
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;
    const sourceItem = [{ hash: encodePath(SOURCE_ID, SOURCE_PATH), isDir: false }];

// 1) Before sending, first verify if the source and target paths are valid.
    const validation = await api("POST", "/api/transfers/validate-path", token, { sourceId: SOURCE_ID, targetId: TARGET_ID, sourceItem, targetPath: TARGET_PATH });
    console.log("validate-path", validation);

// 2) Combine filters, path mapping, and conflict policies in a single request and send them.
    const transfer = await api("POST", "/api/transfers/manual", token, {
        sourceId: SOURCE_ID,
        targetId: TARGET_ID,
        targetPath: TARGET_PATH,
        sourceItem,
        sendAllFolder: false,
transferOptions: {
"send-filetype-cus": "\\.(log|csv)$", // Filter: log·csv extensions only
savepath: true, // Path mapping: preserve source folder structure
            optionPath: "relative",
"target-action": "numbering", // Conflict policy: assign (1) after name
        },
});
    console.log("transfer created", { monitorId: transfer.monitorId, status: transfer.status });

// 3) Check until completed.
    await waitForCompletion(transfer.monitorId, token);
    console.log("Transfer completed");
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "sourceId": "device-source-01",
  "targetId": "device-target-01",
  "targetPath": "/data/incoming",
  "sourceItem": [{ "hash": "device-source-01_ino_L2RhdGEvbG9ncw==", "isDir": true }],
  "sendAllFolder": true,
  "filter": {
    "recursive": true,
    "includeExtensions": ["log", "csv"],
    "excludePatterns": ["*.tmp"],
    "minSize": 1024,
    "modifiedAfter": "2026-08-01T00:00:00Z"
}
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "monitorId": "mon-abc123", "transferId": "tr-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01";
const TARGET_ID = process.env.INNORIX_TARGET_ID || "device-target-01";
const SOURCE_PATH = process.env.INNORIX_SOURCE_PATH || "/var/log";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/collect/logs";
const TRANSFER_STATUS = Object.freeze({ transferComplete: 2, transferError: 4, transferCancel: 5, transferPartialComplete: 9, transferFail: 99 });
const TERMINAL_STATUSES = new Set(Object.values(TRANSFER_STATUS));

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function waitForCompletion(monitorId, token) {
for (;;) {
        const detail = await api("GET", `/api/transfers/${monitorId}`, token);
        console.log({ monitorId, status: detail.status, percent: detail.percent || 0 });
if (detail.isTerminal ?? TERMINAL_STATUSES.has(detail.status)) {
            if (detail.status !== TRANSFER_STATUS.transferComplete) throw new Error(detail.errorCode || "Transfer failed");
return detail;
}
        await new Promise((resolve) => setTimeout(resolve, 2000));
}
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

// Recursively transfer only *.log and *.csv files modified since yesterday that are 1KB or larger, excluding *.tmp files, and including subfolders.
const yesterday = new Date(Date.now() - 86400000).toISOString();
    const transfer = await api("POST", "/api/transfers/filtered", token, {
        sourceId: SOURCE_ID,
        targetId: TARGET_ID,
        targetPath: TARGET_PATH,
        sourceItem: [{ hash: encodePath(SOURCE_ID, SOURCE_PATH), isDir: true }],
        sendAllFolder: true,
filter: {
            recursive: true,
            includeExtensions: ["log", "csv"],
            excludePatterns: ["*.tmp"],
            minSize: 1024,
            modifiedAfter: yesterday,
        },
});
    console.log("transfer created", { monitorId: transfer.monitorId, status: transfer.status });

    await waitForCompletion(transfer.monitorId, token);
    console.log("Transfer completed");
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "sourceId": "device-source-01",
  "targetId": "device-target-01",
  "targetPath": "/data/incoming/2026",
  "sourceItem": [{ "hash": "device-source-01_ino_L2RhdGEvcmVwb3J0LnBkZg==", "isDir": false }]
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "monitorId": "mon-abc123", "transferId": "tr-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01";
const TARGET_ID = process.env.INNORIX_TARGET_ID || "device-target-01";
const SOURCE_PATH = process.env.INNORIX_SOURCE_PATH || "/data/report.pdf";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/data/incoming/2026/08";
const REQUIRED_BYTES = process.env.INNORIX_SOURCE_SIZE || "107374182400";
const TRANSFER_STATUS = Object.freeze({ transferComplete: 2, transferError: 4, transferCancel: 5, transferPartialComplete: 9, transferFail: 99 });
const TERMINAL_STATUSES = new Set(Object.values(TRANSFER_STATUS));

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function waitForCompletion(monitorId, token) {
for (;;) {
        const detail = await api("GET", `/api/transfers/${monitorId}`, token);
        console.log({ monitorId, status: detail.status, percent: detail.percent || 0 });
if (detail.isTerminal ?? TERMINAL_STATUSES.has(detail.status)) {
            if (detail.status !== TRANSFER_STATUS.transferComplete) throw new Error(detail.errorCode || "Transfer failed");
return detail;
}
        await new Promise((resolve) => setTimeout(resolve, 2000));
}
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

// 1) Create a date folder that does not exist in the target.
    await api("POST", `/api/devices/${TARGET_ID}/files/folders`, token, { path: TARGET_PATH });

2) Check if there is enough remaining disk space, and if not, fail the transfer beforehand.
    const capacity = await api("GET", `/api/devices/${TARGET_ID}/capacity?path=${encodeURIComponent(TARGET_PATH)}&requiredBytes=${REQUIRED_BYTES}`, token);
    if (capacity.sufficient !== true) throw new Error("Target capacity was not confirmed");

// 3) Once the capacity is confirmed, send.
    const transfer = await api("POST", "/api/transfers/manual", token, {
        sourceId: SOURCE_ID,
        targetId: TARGET_ID,
        targetPath: TARGET_PATH,
        sourceItem: [{ hash: encodePath(SOURCE_ID, SOURCE_PATH), isDir: false }],
        sendAllFolder: false,
});
    console.log("transfer created", { monitorId: transfer.monitorId, status: transfer.status });

    await waitForCompletion(transfer.monitorId, token);
    console.log("Transfer completed");
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "sourceId": "device-source-01",
  "targetId": "device-target-01",
  "targetPath": "/archive",
  "sourceItem": [{ "hash": "device-source-01_ino_L2RhdGEvMjAyNi9yZXBvcnRz", "isDir": true }],
  "sendAllFolder": true,
  "transferOptions": {
    "pathMapping": {
      "preserveStructure": true,
      "removePrefix": "/data/2026",
      "targetRoot": "/archive",
      "fileNameTemplate": "20260825_{name}",
      "createTargetFolders": true
}
}
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "monitorId": "mon-abc123", "transferId": "tr-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01";
const TARGET_ID = process.env.INNORIX_TARGET_ID || "device-target-01";
const SOURCE_PATH = process.env.INNORIX_SOURCE_PATH || "/data/2026/report.pdf";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/archive";
const TRANSFER_STATUS = Object.freeze({ transferComplete: 2, transferError: 4, transferCancel: 5, transferPartialComplete: 9, transferFail: 99 });
const TERMINAL_STATUSES = new Set(Object.values(TRANSFER_STATUS));

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function waitForCompletion(monitorId, token) {
for (;;) {
        const detail = await api("GET", `/api/transfers/${monitorId}`, token);
        console.log({ monitorId, status: detail.status, percent: detail.percent || 0 });
if (detail.isTerminal ?? TERMINAL_STATUSES.has(detail.status)) {
            if (detail.status !== TRANSFER_STATUS.transferComplete) throw new Error(detail.errorCode || "Transfer failed");
return detail;
}
        await new Promise((resolve) => setTimeout(resolve, 2000));
}
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

// Creates the transfer date (YYYYMMDD) to prepend to the filename.
    const today = new Date().toISOString().slice(0, 10).replaceAll("-", "");

// Maintain the source folder structure but remove the /data/2026 prefix path,
// Append the transfer date to the beginning of the filename and place it under /archive.
    const transfer = await api("POST", "/api/transfers/manual", token, {
        sourceId: SOURCE_ID,
        targetId: TARGET_ID,
        targetPath: TARGET_PATH,
        sourceItem: [{ hash: encodePath(SOURCE_ID, SOURCE_PATH), isDir: false }],
        sendAllFolder: false,
transferOptions: {
pathMapping: {
                preserveStructure: true,
                removePrefix: "/data/2026",
                targetRoot: "/archive",
                fileNameTemplate: `${today}_{name}`,
                createTargetFolders: true,
            },
        },
});
    console.log("transfer created", { monitorId: transfer.monitorId, status: transfer.status });

    await waitForCompletion(transfer.monitorId, token);
    console.log("Transfer completed");
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "sourceId": "device-source-01",
  "targetId": "device-target-01",
  "targetPath": "/data/incoming",
  "sourceItem": [{ "hash": "device-source-01_ino_L2RhdGEvcmVwb3J0LnBkZg==", "isDir": false }],
  "transferOptions": { "target-action": "numbering" }
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "monitorId": "mon-abc123", "transferId": "tr-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01";
const TARGET_ID = process.env.INNORIX_TARGET_ID || "device-target-01";
const SOURCE_PATH = process.env.INNORIX_SOURCE_PATH || "/data/report.pdf";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/data/incoming";
// Check how the results change by changing the conflict policy.
const CONFLICT_POLICIES = ["numbering", "skip", "overwrite", "fail"];
const TRANSFER_STATUS = Object.freeze({ transferComplete: 2, transferError: 4, transferCancel: 5, transferPartialComplete: 9, transferFail: 99 });
const TERMINAL_STATUSES = new Set(Object.values(TRANSFER_STATUS));

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function waitForTerminal(monitorId, token) {
The fail policy intentionally fails, so it waits only until 'termination' rather than completion.
for (;;) {
        const detail = await api("GET", `/api/transfers/${monitorId}`, token);
if (detail.isTerminal ?? TERMINAL_STATUSES.has(detail.status)) return detail;
        await new Promise((resolve) => setTimeout(resolve, 2000));
}
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

    const sourceItem = [{ hash: encodePath(SOURCE_ID, SOURCE_PATH), isDir: false }];
for (const policy of CONFLICT_POLICIES) {
// Send the same file to the same location, but change only the conflict policy.
        const transfer = await api("POST", "/api/transfers/manual", token, {
            sourceId: SOURCE_ID,
            targetId: TARGET_ID,
            targetPath: TARGET_PATH,
            sourceItem,
            sendAllFolder: false,
            transferOptions: { "target-action": policy },
});
        const detail = await waitForTerminal(transfer.monitorId, token);

// Retrieves file-level results by policy
        const files = await api("GET", `/api/transfers/${transfer.monitorId}/files?state=any&size=100`, token);
        console.log(`policy=${policy} status=${detail.status}`, files.items?.map((file) => ({ name: file.name, state: file.state })));
}
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "name": "Daily Settlement Transfer",
  "transferType": "normal",
  "timezone": "Asia/Seoul",
  "details": [
{
      "senderId": "device-src-001",
      "receiverId": "device-hq-001",
      "targetPath": "/collect/logs",
      "sourceItem": [{ "hash": "device-src-001_ino_...", "isDir": false }],
      "step": 1,
      "transferOptions": { "noSchedule": false, "target-action": "numbering", "send-fileoption": {} }
}
  ],
  "schedules": [
    { "type": "day", "startDateType": "now", "hour": "02", "minute": "00", "ampm": "am", "startDate": "2026-08-25T00:00:00Z", "timezone": "Asia/Seoul" }
]
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "automationId": "auto-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01";
const TARGET_ID = process.env.INNORIX_TARGET_ID || "device-target-01";
const SOURCE_PATH = process.env.INNORIX_SOURCE_PATH || "/data/report.pdf";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/data/incoming";
const TIMEZONE = process.env.INNORIX_TIMEZONE || "UTC";

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

// Schedule to send the previous day's settlement file to the head office server at 2 AM every day.
    const schedule = { type: "day", startDateType: "now", hour: "02", minute: "00", ampm: "am", startDate: new Date().toISOString(), timezone: TIMEZONE };

// 1) Register Schedule
    const created = await api("POST", "/api/automations", token, {
        name: "Daily Settlement Transfer",
        details: [{ sourceItem: [{ hash: encodePath(SOURCE_ID, SOURCE_PATH), isDir: false }], targetPath: TARGET_PATH, senderId: SOURCE_ID, receiverId: TARGET_ID, step: 1, transferOptions: { noSchedule: false, "target-action": "numbering", "send-fileoption": {} } }],
        transferType: "normal",
        timezone: TIMEZONE,
        schedules: [schedule],
});
const automationId = created.automationId;
    console.log("automation created", automationId);

// 2) View Schedule
    console.log("detail", await api("GET", `/api/automations/${automationId}`, token));

// 3) Schedule Modification
    await api("PATCH", `/api/automations/${automationId}`, token, { name: "Daily Settlement Transfer", isUpdateSchedule: true, schedules: [schedule] });

// 4) View past execution history
    console.log("executions", await api("GET", `/api/automations/${automationId}/executions`, token));

// 5) Pause
    await api("POST", `/api/automations/${automationId}/pause`, token, { pause: true });

// 6) Delete (Example cleanup)
    await api("DELETE", `/api/automations/${automationId}`, token);
    console.log("automation deleted", automationId);
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "url": "https://internal.example.com/innorix",
  "events": ["transfer.succeeded", "transfer.failed"],
  "active": true,
  "retryPolicy": { "maxAttempts": 5, "initialDelaySeconds": 30 }
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "webhookId": "wh-abc123" }
}

const { createHmac, timingSafeEqual } = require("node:crypto");

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const WEBHOOK_URL = process.env.INNORIX_WEBHOOK_URL || "https://internal.example.com/innorix";

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function verifySignature(secret, timestamp, rawBody, receivedSignature) {
// Verify (timestamp.body) with HMAC-SHA256 whether the notification is not forged.
    const expected = "sha256=" + createHmac("sha256", secret).update(`${timestamp}.${rawBody}`).digest("hex");
const a = Buffer.from(expected);
    const b = Buffer.from(receivedSignature || "");
    return a.length === b.length && timingSafeEqual(a, b);
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

// 1) Register a webhook to receive transmission completion and failure events.
    const created = await api("POST", "/api/webhooks", token, {
        url: WEBHOOK_URL,
        events: ["transfer.succeeded", "transfer.failed"],
        active: true,
retryPolicy: { maxAttempts: 5, initialDelaySeconds: 30 }, // Re-notify if our server is down
});
const webhookId = created.webhookId;
    console.log("webhook created", webhookId);

// 2) Verify the signature of the notification received from the receiving side. (Inject the actual value into an environment variable)
if (process.env.INNORIX_WEBHOOK_SECRET) {
        const ok = verifySignature(process.env.INNORIX_WEBHOOK_SECRET, process.env.INNORIX_WEBHOOK_TIMESTAMP, process.env.INNORIX_WEBHOOK_PAYLOAD, process.env.INNORIX_WEBHOOK_SIGNATURE);
        if (!ok) throw new Error("Invalid webhook signature");
        console.log("Webhook signature verified");
}

// 3) Check the notification transmission history.
    const deliveries = await api("GET", `/api/webhooks/${webhookId}/deliveries?limit=20`, token);
    console.log("deliveries", deliveries);

// 4) Resend the failed notification.
    const failed = deliveries.items?.find((item) => item.status !== "delivered");
    if (failed) await api("POST", `/api/webhooks/${webhookId}/deliveries/${failed.deliveryId}/retry`, token);
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});

{
  "name": "A to B to C Workflow",
  "flowName": "A-B-C Workflow",
  "transferType": "normal",
  "timezone": "Asia/Seoul",
  "details": [
    { "senderId": "device-a", "receiverId": "device-b", "targetPath": "/data/incoming", "sourceItem": [{ "hash": "device-a_ino_...", "isDir": false }], "step": 1, "transferOptions": { "target-action": "numbering" } },
    { "senderId": "device-b", "receiverId": "device-c", "targetPath": "/data/incoming", "sourceItem": [{ "hash": "device-b_ino_...", "isDir": false }], "step": 2, "transferOptions": { "target-action": "numbering" } }
]
}

{
  "status_code": 201,
  "message": "Created",
  "data": { "automationId": "auto-flow-abc123" }
}

const BASE_URL = process.env.INNORIX_BASE_URL || "https://app.innorix.com";
const WORKSPACE_ID = process.env.INNORIX_WORKSPACE_ID;
const SOURCE_ID = process.env.INNORIX_SOURCE_ID || "device-source-01"; // A
const MIDDLE_ID = process.env.INNORIX_MIDDLE_ID || "device-middle-01"; // B
const TARGET_ID = process.env.INNORIX_TARGET_ID || "device-target-01"; // C
const SOURCE_PATH = process.env.INNORIX_SOURCE_PATH || "/data/report.pdf";
const MIDDLE_PATH = process.env.INNORIX_MIDDLE_PATH || SOURCE_PATH;
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/data/incoming";
const TIMEZONE = process.env.INNORIX_TIMEZONE || "UTC";

async function api(method, path, token, body) {
    const response = await fetch(BASE_URL + path, {
        method,
headers: {
            "Content-Type": "application/json",
            ...(token && { Authorization: `Bearer ${token}`, "x-workspace-id": WORKSPACE_ID }),
        },
        ...(body && { body: JSON.stringify(body) }),
});
const payload = await response.json();
if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);
return payload.data;
}

function encodePath(deviceId, path) {
// Normalize the path separator and encode it in Base64 based on UTF-8.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function main() {
    const login = await api("POST", "/api/auth/login", null, { email: process.env.INNORIX_EMAIL, password: process.env.INNORIX_PASSWORD });
const token = login.user.accessToken;

// Define the A→B→C chain transfer on the server. B→C follows the step order
// After A→B is completed, the server automatically continues execution. (Not client polling assembly)
    const created = await api("POST", "/api/automations", token, {
        name: "A to B to C Workflow",
        flowName: "A-B-C Workflow",
details: [
            { sourceItem: [{ hash: encodePath(SOURCE_ID, SOURCE_PATH), isDir: false }], targetPath: TARGET_PATH, senderId: SOURCE_ID, receiverId: MIDDLE_ID, step: 1, transferOptions: { noSchedule: false, "target-action": "numbering", "send-fileoption": {} } },
            { sourceItem: [{ hash: encodePath(MIDDLE_ID, MIDDLE_PATH), isDir: false }], targetPath: TARGET_PATH, senderId: MIDDLE_ID, receiverId: TARGET_ID, step: 2, transferOptions: { noSchedule: false, "target-action": "numbering", "send-fileoption": {} } },
        ],
        transferType: "normal",
        timezone: TIMEZONE,
        schedules: [{ type: "none", startDateType: "now", hour: "00", minute: "00", ampm: "am", startDate: new Date().toISOString(), timezone: TIMEZONE }],
});
const automationId = created.automationId;
    console.log("workflow created", automationId);

// View step definitions and overall execution status.
    console.log("steps", await api("GET", `/api/automations/${automationId}/details`, token));
    console.log("executions", await api("GET", `/api/automations/${automationId}/executions`, token));
}

main().catch((error) => {
console.error(error.message);
process.exitCode = 1;
});