애플리케이션에 시스템 간 파일 전송

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": "연결됨",
        "isConnected": true
      }
    ]
  }
}

{
  "status_code": 200,
  "message": "OK",
  "data": {
    "path": "/data", "total": 128, "page": 1, "size": 50, "lastPage": 3,
    "items": [
      {
        "name": "보고서.pdf",
        "path": "/data/보고서.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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    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;

    // 보낼 항목은 sourceItem의 hash로 지정한다.
    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) {
    // UTF-8 Base64 인코딩 전에 경로 구분자를 정규화한다.
    const normalizedPath = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalizedPath, "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;
    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);
    }

    // 모든 monitorId가 종료될 때까지 병렬 작업의 전체 완료 상태를 집계한다.
    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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    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;

    // 본사에서 배포 패키지 폴더를 한 번 검색한다.
    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 }];

    // 동일한 패키지를 여러 타깃으로 각각 전송한다.
    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);
    }

    // 종료된 타깃을 성공과 실패 목록으로 나누어 집계한다.
    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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    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) 보내기 전에 소스·타깃 경로가 유효한지 먼저 검증한다.
    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) 필터·경로매핑·충돌정책을 한 요청에 조합해 전송한다.
    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)$", // 필터: log·csv 확장자만
            savepath: true, // 경로 매핑: 소스 폴더 구조 유지
            optionPath: "relative",
            "target-action": "numbering", // 충돌 정책: 이름 뒤 (1) 부여
        },
    });
    console.log("transfer created", { monitorId: transfer.monitorId, status: transfer.status });

    // 3) 완료될 때까지 확인한다.
    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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    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;

    // 어제 이후 수정된 *.log·*.csv 중 1KB 이상만, *.tmp는 제외하고 하위 폴더까지 재귀 전송한다.
    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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    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) 타깃에 없는 날짜 폴더를 만든다.
    await api("POST", `/api/devices/${TARGET_ID}/files/folders`, token, { path: TARGET_PATH });

    // 2) 남은 디스크 용량이 충분한지 확인하고, 부족하면 전송 전에 실패시킨다.
    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) 용량이 확인되면 전송한다.
    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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    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;

    // 파일명 앞에 붙일 전송일자(YYYYMMDD)를 만든다.
    const today = new Date().toISOString().slice(0, 10).replaceAll("-", "");

    // 소스 폴더 구조는 유지하되 /data/2026 접두 경로를 떼고,
    // 파일명 앞에 전송일자를 붙여 /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";
// 충돌 정책을 바꿔가며 결과가 어떻게 달라지는지 확인한다.
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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    const normalized = path.replaceAll("\\", "/");
    return `${deviceId}_ino_${Buffer.from(normalized, "utf8").toString("base64")}`;
}

async function waitForTerminal(monitorId, token) {
    // fail 정책은 의도적으로 실패하므로 완료가 아닌 '종료'까지만 기다린다.
    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) {
        // 같은 파일을 같은 위치로 보내되 충돌 정책만 바꾼다.
        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);

        // 정책별로 파일 단위 결과를 조회한다.
        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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    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;

    // 매일 새벽 2시에 전일 정산 파일을 본사 서버로 보내는 일정.
    const schedule = { type: "day", startDateType: "now", hour: "02", minute: "00", ampm: "am", startDate: new Date().toISOString(), timezone: TIMEZONE };

    // 1) 일정 등록
    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) 일정 조회
    console.log("detail", await api("GET", `/api/automations/${automationId}`, token));

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

    // 4) 지난 실행 이력 조회
    console.log("executions", await api("GET", `/api/automations/${automationId}/executions`, token));

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

    // 6) 삭제 (예제 정리)
    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) {
    // 통보가 위조되지 않았는지 (timestamp.body)를 HMAC-SHA256으로 검증한다.
    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) 전송 완료·실패 이벤트를 통보받을 웹훅을 등록한다.
    const created = await api("POST", "/api/webhooks", token, {
        url: WEBHOOK_URL,
        events: ["transfer.succeeded", "transfer.failed"],
        active: true,
        retryPolicy: { maxAttempts: 5, initialDelaySeconds: 30 }, // 우리 서버가 죽어 있었으면 재통보
    });
    const webhookId = created.webhookId;
    console.log("webhook created", webhookId);

    // 2) 수신 측에서 받은 통보의 서명을 검증한다. (환경변수로 실제 값 주입)
    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) 통보 전송 이력을 조회한다.
    const deliveries = await api("GET", `/api/webhooks/${webhookId}/deliveries?limit=20`, token);
    console.log("deliveries", deliveries);

    // 4) 실패한 통보를 재전송한다.
    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) {
    // 경로 구분자를 정규화한 뒤 UTF-8 기준 Base64로 인코딩한다.
    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;

    // A→B→C 체인 전송을 서버에 정의한다. B→C는 step 순서에 따라
    // A→B 완료 후 서버가 자동으로 이어서 실행한다. (클라이언트 폴링 조립 아님)
    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);

    // 단계별 정의와 전체 실행 상태를 조회한다.
    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;
});

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/master";
const TARGET_PATH = process.env.INNORIX_TARGET_PATH || "/data/mirror";

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 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 created = await api("POST", "/api/sync/jobs", token, {
        source: { deviceId: SOURCE_ID, path: SOURCE_PATH },
        target: { deviceId: TARGET_ID, path: TARGET_PATH },
        mode: "one-way",
    });
    const jobId = created.jobId;
    console.log("sync job created", jobId);
    console.log("detail", await api("GET", `/api/sync/jobs/${jobId}`, token));
    await api("POST", `/api/sync/jobs/${jobId}/pause`, token);
    console.log("paused", jobId);
    await api("POST", `/api/sync/jobs/${jobId}/resume`, token);
    console.log("resumed", jobId);
    await api("DELETE", `/api/sync/jobs/${jobId}`, token);
    console.log("deleted", jobId);
}

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