@sstar/embedlink_agent 0.1.0

package/dist/tftp/client.js

@@ -0,0 +1,345 @@
+import dgram from 'node:dgram';
+const OPCODES = {
+    RRQ: 1,
+    WRQ: 2,
+    DATA: 3,
+    ACK: 4,
+    ERROR: 5,
+};
+const DEFAULT_BLOCK_SIZE = 512;
+const DEFAULT_TIMEOUT_MS = 5000;
+// 统一的客户端重试配置（保持默认轻量重试）
+const TFTP_CLIENT_CONFIG = {
+    MAX_RETRIES: 3,
+    TIMEOUT_MS: DEFAULT_TIMEOUT_MS,
+    INITIAL_BACKOFF_MS: 500,
+    MAX_BACKOFF_MS: 3000,
+};
+function createRequestPacket(opcode, filename, mode) {
+    const nameBuf = Buffer.from(filename, 'ascii');
+    const modeBuf = Buffer.from(mode, 'ascii');
+    const buf = Buffer.alloc(2 + nameBuf.length + 1 + modeBuf.length + 1);
+    buf.writeUInt16BE(opcode, 0);
+    let offset = 2;
+    nameBuf.copy(buf, offset);
+    offset += nameBuf.length;
+    buf[offset++] = 0;
+    modeBuf.copy(buf, offset);
+    offset += modeBuf.length;
+    buf[offset++] = 0;
+    return buf;
+}
+function createDataPacket(blockNumber, data) {
+    const buf = Buffer.alloc(4 + data.length);
+    buf.writeUInt16BE(OPCODES.DATA, 0);
+    buf.writeUInt16BE(blockNumber, 2);
+    data.copy(buf, 4);
+    return buf;
+}
+function createAckPacket(blockNumber) {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt16BE(OPCODES.ACK, 0);
+    buf.writeUInt16BE(blockNumber, 2);
+    return buf;
+}
+function parseErrorPacket(buf) {
+    const code = buf.readUInt16BE(2);
+    const msg = buf.slice(4, buf.length - 1).toString('ascii');
+    return { code, message: msg };
+}
+// 通用重试机制函数
+function createRetryWrapper(operation, operationName, maxRetries = TFTP_CLIENT_CONFIG.MAX_RETRIES) {
+    return new Promise((resolve, reject) => {
+        let retryCount = 0;
+        let backoffMs = TFTP_CLIENT_CONFIG.INITIAL_BACKOFF_MS;
+        function attempt() {
+            operation()
+                .then(resolve)
+                .catch((err) => {
+                retryCount++;
+                if (retryCount >= maxRetries) {
+                    reject(new Error(`${operationName} failed after ${maxRetries} retries: ${err.message}`));
+                    return;
+                }
+                setTimeout(attempt, backoffMs);
+                backoffMs = Math.min(backoffMs * 2, TFTP_CLIENT_CONFIG.MAX_BACKOFF_MS);
+            });
+        }
+        attempt();
+    });
+}
+export async function tftpPut(host, port, remotePath, content) {
+    const targetPort = port || 69;
+    const fileName = remotePath || '';
+    const blockSize = DEFAULT_BLOCK_SIZE;
+    const totalBlocks = Math.max(1, Math.ceil(content.length / blockSize));
+    return new Promise((resolve, reject) => {
+        const socket = dgram.createSocket('udp4');
+        let remoteAddress = host;
+        let remotePort = targetPort;
+        let sessionAddress = null;
+        let sessionPort = null;
+        let currentBlock = 0;
+        let retries = 0;
+        let timeout = null;
+        let closed = false;
+        function clearTimer() {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+        }
+        function cleanup(err) {
+            if (closed)
+                return;
+            closed = true;
+            clearTimer();
+            try {
+                socket.close();
+            }
+            catch { }
+            if (err)
+                reject(err);
+            else
+                resolve();
+        }
+        function armTimeout(onTimeout) {
+            clearTimer();
+            timeout = setTimeout(onTimeout, TFTP_CLIENT_CONFIG.TIMEOUT_MS);
+        }
+        // WRQ发送（只对初始请求使用重试）
+        let wrqRetries = 0;
+        function sendWrq() {
+            const pkt = createRequestPacket(OPCODES.WRQ, fileName, 'octet');
+            socket.send(pkt, targetPort, host, (err) => {
+                if (err) {
+                    cleanup(err);
+                    return;
+                }
+                armTimeout(() => {
+                    wrqRetries++;
+                    if (wrqRetries >= TFTP_CLIENT_CONFIG.MAX_RETRIES) {
+                        cleanup(new Error(`TFTP WRQ timeout to ${host}:${targetPort} after ${TFTP_CLIENT_CONFIG.MAX_RETRIES} retries`));
+                    }
+                    else {
+                        // 指数退避重试
+                        const backoff = Math.min(TFTP_CLIENT_CONFIG.INITIAL_BACKOFF_MS * Math.pow(2, wrqRetries - 1), TFTP_CLIENT_CONFIG.MAX_BACKOFF_MS);
+                        setTimeout(sendWrq, backoff);
+                    }
+                });
+            });
+        }
+        // 数据块发送（带重试机制）
+        let dataRetries = 0;
+        function sendBlock(blockNo) {
+            currentBlock = blockNo;
+            const start = (blockNo - 1) * blockSize;
+            const end = blockNo === totalBlocks ? content.length : Math.min(start + blockSize, content.length);
+            const slice = content.subarray(start, end);
+            const pkt = createDataPacket(blockNo, slice);
+            socket.send(pkt, remotePort, remoteAddress, (err) => {
+                if (err) {
+                    cleanup(err);
+                    return;
+                }
+                armTimeout(() => {
+                    dataRetries++;
+                    if (dataRetries >= TFTP_CLIENT_CONFIG.MAX_RETRIES) {
+                        cleanup(new Error(`TFTP DATA block ${blockNo} timeout after ${TFTP_CLIENT_CONFIG.MAX_RETRIES} retries`));
+                    }
+                    else {
+                        // 重新发送同一个数据块
+                        sendBlock(blockNo);
+                    }
+                });
+            });
+        }
+        socket.on('error', (err) => {
+            cleanup(err);
+        });
+        socket.on('message', (msg, rinfo) => {
+            if (closed)
+                return;
+            if (msg.length < 4)
+                return;
+            const opcode = msg.readUInt16BE(0);
+            if (opcode === OPCODES.ERROR) {
+                const { code, message } = parseErrorPacket(msg);
+                cleanup(new Error(`TFTP ERROR ${code}: ${message}`));
+                return;
+            }
+            if (sessionPort == null) {
+                sessionPort = rinfo.port;
+                sessionAddress = rinfo.address;
+                remotePort = sessionPort;
+                remoteAddress = sessionAddress;
+            }
+            if (rinfo.port !== remotePort || rinfo.address !== remoteAddress) {
+                // 忽略来自未知 TID 的数据
+                return;
+            }
+            if (opcode === OPCODES.ACK) {
+                clearTimer();
+                dataRetries = 0; // 重置数据重试计数器
+                const ackBlock = msg.readUInt16BE(2);
+                if (ackBlock === 0 && currentBlock === 0) {
+                    // 收到对 WRQ 的 ACK block 0，开始发送第一个数据块
+                    sendBlock(1);
+                    return;
+                }
+                if (ackBlock === currentBlock) {
+                    if (ackBlock >= totalBlocks) {
+                        cleanup();
+                    }
+                    else {
+                        sendBlock(currentBlock + 1);
+                    }
+                    return;
+                }
+                // 重复 ACK 或过时 ACK，忽略
+                return;
+            }
+        });
+        sendWrq();
+    });
+}
+export async function tftpGet(host, port, remotePath) {
+    const targetPort = port || 69;
+    const fileName = remotePath || '';
+    const blockSize = DEFAULT_BLOCK_SIZE;
+    return new Promise((resolve, reject) => {
+        const socket = dgram.createSocket('udp4');
+        const chunks = [];
+        let remoteAddress = host;
+        let remotePort = targetPort;
+        let sessionAddress = null;
+        let sessionPort = null;
+        let expectedBlock = 1;
+        let timeout = null;
+        let closed = false;
+        function clearTimer() {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+        }
+        function cleanupOk() {
+            if (closed)
+                return;
+            closed = true;
+            clearTimer();
+            try {
+                socket.close();
+            }
+            catch { }
+            resolve(Buffer.concat(chunks));
+        }
+        function cleanupErr(err) {
+            if (closed)
+                return;
+            closed = true;
+            clearTimer();
+            try {
+                socket.close();
+            }
+            catch { }
+            reject(err);
+        }
+        function armTimeout(onTimeout) {
+            clearTimer();
+            timeout = setTimeout(onTimeout, TFTP_CLIENT_CONFIG.TIMEOUT_MS);
+        }
+        // RRQ发送（只对初始请求使用重试）
+        let rrqRetries = 0;
+        function sendRrq() {
+            const pkt = createRequestPacket(OPCODES.RRQ, fileName, 'octet');
+            socket.send(pkt, targetPort, host, (err) => {
+                if (err) {
+                    cleanupErr(err);
+                    return;
+                }
+                armTimeout(() => {
+                    rrqRetries++;
+                    if (rrqRetries >= TFTP_CLIENT_CONFIG.MAX_RETRIES) {
+                        cleanupErr(new Error(`TFTP RRQ timeout from ${host}:${targetPort} after ${TFTP_CLIENT_CONFIG.MAX_RETRIES} retries`));
+                    }
+                    else {
+                        // 指数退避重试
+                        const backoff = Math.min(TFTP_CLIENT_CONFIG.INITIAL_BACKOFF_MS * Math.pow(2, rrqRetries - 1), TFTP_CLIENT_CONFIG.MAX_BACKOFF_MS);
+                        setTimeout(sendRrq, backoff);
+                    }
+                });
+            });
+        }
+        // ACK发送（带重试机制）
+        let ackRetries = 0;
+        function sendAck(blockNo) {
+            const pkt = createAckPacket(blockNo);
+            socket.send(pkt, remotePort, remoteAddress, (err) => {
+                if (err) {
+                    cleanupErr(err);
+                    return;
+                }
+                armTimeout(() => {
+                    ackRetries++;
+                    if (ackRetries >= TFTP_CLIENT_CONFIG.MAX_RETRIES) {
+                        cleanupErr(new Error(`TFTP DATA timeout waiting after ACK ${blockNo} after ${TFTP_CLIENT_CONFIG.MAX_RETRIES} retries`));
+                    }
+                    else {
+                        // 重新发送同一个ACK
+                        sendAck(blockNo);
+                    }
+                });
+            });
+        }
+        socket.on('error', (err) => {
+            cleanupErr(err);
+        });
+        socket.on('message', (msg, rinfo) => {
+            if (closed)
+                return;
+            if (msg.length < 4)
+                return;
+            const opcode = msg.readUInt16BE(0);
+            if (opcode === OPCODES.ERROR) {
+                const { code, message } = parseErrorPacket(msg);
+                cleanupErr(new Error(`TFTP ERROR ${code}: ${message}`));
+                return;
+            }
+            if (opcode !== OPCODES.DATA) {
+                // 非 DATA 包，忽略
+                return;
+            }
+            if (sessionPort == null) {
+                sessionPort = rinfo.port;
+                sessionAddress = rinfo.address;
+                remotePort = sessionPort;
+                remoteAddress = sessionAddress;
+            }
+            if (rinfo.port !== remotePort || rinfo.address !== remoteAddress) {
+                // 来自未知 TID 的数据，忽略
+                return;
+            }
+            clearTimer();
+            ackRetries = 0; // 重置ACK重试计数器
+            const blockNo = msg.readUInt16BE(2);
+            const data = msg.slice(4);
+            if (blockNo === expectedBlock) {
+                chunks.push(data);
+                sendAck(blockNo);
+                if (data.length < blockSize) {
+                    // 最后一个数据块
+                    cleanupOk();
+                }
+                else {
+                    expectedBlock++;
+                }
+            }
+            else if (blockNo < expectedBlock) {
+                // 重复数据块，重新 ACK
+                sendAck(blockNo);
+            }
+        });
+        sendRrq();
+    });
+}

package/dist/tftp/index.js

@@ -0,0 +1,284 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { error, ErrorCodes } from '../core/errors.js';
+import { TftpServer } from './server.js';
+import { checkPortAvailability } from '../utils/port-check.js';
+import { tftpGet, tftpPut } from './client.js';
+export async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+function normalizePosixSubpath(subpath) {
+    if (!subpath)
+        return '';
+    const replaced = subpath.replace(/\\/g, '/');
+    const parts = replaced.split('/').filter((p) => p && p !== '.' && p !== '..');
+    return parts.join('/');
+}
+function resolveUnderRoot(root, subpath) {
+    const rel = normalizePosixSubpath(subpath);
+    if (!rel)
+        return root;
+    const segments = rel.split('/');
+    return path.join(root, ...segments);
+}
+export async function uploadToTftp(rootDir, remoteSubpath, content) {
+    try {
+        const full = resolveUnderRoot(rootDir, remoteSubpath);
+        const dir = path.dirname(full);
+        await ensureDir(dir);
+        await fs.writeFile(full, content);
+        const stat = await fs.stat(full);
+        const size = stat.size;
+        const sha256 = crypto.createHash('sha256').update(content).digest('hex');
+        return { path: full, size, sha256 };
+    }
+    catch (e) {
+        throw error(ErrorCodes.EL_TFTP_UPLOAD_FAILED, e?.message || String(e));
+    }
+}
+export async function downloadFromTftp(rootDir, remoteSubpath) {
+    const full = resolveUnderRoot(rootDir, remoteSubpath);
+    try {
+        const buf = await fs.readFile(full);
+        const stat = await fs.stat(full);
+        return { content: buf, size: stat.size };
+    }
+    catch (e) {
+        throw error(ErrorCodes.EL_TFTP_VERIFY_FAILED, e?.message || String(e));
+    }
+}
+export async function uploadToExternalTftp(host, port, remoteSubpath, content) {
+    const pathPosix = normalizePosixSubpath(remoteSubpath);
+    try {
+        await tftpPut(host, port || 69, pathPosix, content);
+        const sha256 = crypto.createHash('sha256').update(content).digest('hex');
+        return { remoteSubpath: pathPosix, size: content.byteLength, sha256 };
+    }
+    catch (e) {
+        throw error(ErrorCodes.EL_TFTP_UPLOAD_FAILED, e?.message || String(e) || 'external TFTP upload failed');
+    }
+}
+export async function downloadFromExternalTftp(host, port, remoteSubpath) {
+    const pathPosix = normalizePosixSubpath(remoteSubpath);
+    try {
+        const buf = await tftpGet(host, port || 69, pathPosix);
+        return { content: buf, size: buf.byteLength };
+    }
+    catch (e) {
+        throw error(ErrorCodes.EL_TFTP_VERIFY_FAILED, e?.message || String(e) || 'external TFTP download failed');
+    }
+}
+export async function listTftpEntries(rootDir, baseSubpath, depth, maxEntries = 1000) {
+    const entries = [];
+    let truncated = false;
+    const start = resolveUnderRoot(rootDir, baseSubpath);
+    const basePrefix = path.resolve(rootDir);
+    async function walk(currentPath, currentDepth) {
+        if (entries.length >= maxEntries) {
+            truncated = true;
+            return;
+        }
+        const relFull = path.relative(basePrefix, currentPath) || '';
+        const name = path.basename(currentPath) || '';
+        const st = await fs.stat(currentPath).catch(() => null);
+        if (!st)
+            return;
+        const isDir = st.isDirectory();
+        const toPosix = (p) => p.split(path.sep).join('/');
+        entries.push({
+            path: toPosix(relFull),
+            name,
+            isDirectory: isDir,
+            sizeBytes: isDir ? 0 : st.size,
+            modifiedAtMs: st.mtimeMs || 0,
+        });
+        if (!isDir)
+            return;
+        if (depth === 0 || currentDepth >= depth)
+            return;
+        const children = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const ent of children) {
+            const childFull = path.join(currentPath, ent.name);
+            await walk(childFull, currentDepth + 1);
+            if (truncated)
+                return;
+        }
+    }
+    try {
+        await walk(start, 0);
+    }
+    catch {
+        // 如果目录不存在，返回空列表
+    }
+    return { entries, truncated };
+}
+export async function cleanupTftpDir(dir, ttlMs) {
+    const now = Date.now();
+    const removed = [];
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const ent of entries) {
+            if (!ent.isFile())
+                continue;
+            const full = path.join(dir, ent.name);
+            try {
+                const stat = await fs.stat(full);
+                const mtimeMs = stat.mtimeMs || stat.ctimeMs || 0;
+                if (mtimeMs && now - mtimeMs > ttlMs) {
+                    await fs.unlink(full);
+                    removed.push(full);
+                }
+            }
+            catch {
+                // ignore individual file errors
+            }
+        }
+    }
+    catch {
+        // directory may not exist yet; treat as no-op
+    }
+    return removed;
+}
+// TFTP服务器管理
+let globalTftpServer = null;
+let lastTftpStatus = {
+    mode: 'builtin',
+    enabled: false,
+    isRunning: false,
+};
+/**
+ * 启动TFTP服务器
+ */
+export async function startTftpServer(cfg) {
+    const serverConfig = cfg.tftp.server;
+    if (!serverConfig || serverConfig.enabled === false || serverConfig.mode === 'disabled') {
+        // 完全禁用模式
+        globalTftpServer = null;
+        lastTftpStatus = {
+            mode: 'disabled',
+            enabled: false,
+            isRunning: false,
+        };
+        return;
+    }
+    if (serverConfig.mode === 'external') {
+        await startExternalTftpServer(cfg);
+        return;
+    }
+    await startBuiltinTftpServer(cfg);
+}
+/**
+ * 启动内置TFTP服务器
+ */
+async function startBuiltinTftpServer(cfg) {
+    const serverConfig = cfg.tftp.server;
+    const host = serverConfig.host || '0.0.0.0';
+    const port = serverConfig.port || 69;
+    // 先检查端口可用性（包含端口占用及权限不足）
+    try {
+        const portCheck = await checkPortAvailability(port, host);
+        if (!portCheck.available) {
+            lastTftpStatus = {
+                mode: 'builtin',
+                enabled: true,
+                isRunning: false,
+                host,
+                port,
+                lastError: portCheck.process?.command
+                    ? `port ${port} unavailable, occupied by ${portCheck.process.command}`
+                    : `port ${port} unavailable`,
+                conflictProcess: portCheck.process,
+            };
+            globalTftpServer = null;
+            return;
+        }
+    }
+    catch (e) {
+        // 端口检查出现异常，一并记录，但不中断 Agent 其它功能
+        lastTftpStatus = {
+            mode: 'builtin',
+            enabled: true,
+            isRunning: false,
+            host,
+            port,
+            lastError: e?.message || String(e),
+        };
+        globalTftpServer = null;
+        return;
+    }
+    const tftpConfig = {
+        port,
+        host,
+        rootDir: cfg.tftp.dir,
+        timeout: serverConfig.timeout,
+        retryCount: serverConfig.retryCount,
+        blockSize: serverConfig.blockSize,
+    };
+    try {
+        const server = new TftpServer(tftpConfig);
+        globalTftpServer = server;
+        await server.start();
+        const stats = server.getStats();
+        lastTftpStatus = {
+            mode: 'builtin',
+            enabled: true,
+            isRunning: true,
+            host: stats.host,
+            port: stats.port,
+            uptimeMs: stats.uptime,
+            requestsHandled: stats.requestsHandled,
+            errors: stats.errors,
+            activeConnections: stats.activeConnections,
+        };
+    }
+    catch (e) {
+        lastTftpStatus = {
+            mode: 'builtin',
+            enabled: true,
+            isRunning: false,
+            host,
+            port,
+            lastError: e?.message || String(e),
+        };
+        globalTftpServer = null;
+    }
+}
+/**
+ * 启动外部TFTP服务器模式
+ */
+async function startExternalTftpServer(cfg) {
+    const serverConfig = cfg.tftp.server;
+    lastTftpStatus = {
+        mode: 'external',
+        enabled: true,
+        isRunning: true,
+        externalHost: serverConfig.externalHost,
+        externalPort: serverConfig.externalPort,
+    };
+    // external 模式下不在本机监听 UDP 端口
+    globalTftpServer = null;
+}
+/**
+ * 获取TFTP服务器状态
+ */
+export async function getTftpServerStats() {
+    return lastTftpStatus;
+}
+/**
+ * 停止TFTP服务器
+ */
+export async function stopTftpServer() {
+    if (globalTftpServer) {
+        await globalTftpServer.stop();
+        globalTftpServer = null;
+    }
+    if (lastTftpStatus.mode === 'builtin') {
+        lastTftpStatus = {
+            ...lastTftpStatus,
+            isRunning: false,
+            uptimeMs: 0,
+            activeConnections: 0,
+        };
+    }
+}