@bingzi-233/ssh-mcp 1.3.0 → 1.5.0

package/dist/ops.js

@@ -0,0 +1,470 @@
+import { createWriteStream, createReadStream, statSync } from "node:fs";
+import { createConnection, runCommand } from "./ssh.js";
+// reopen: helper because openSftp is not exported from transfer.ts, but we need it here
+function sftpOpen(conn) {
+    return new Promise((resolve, reject) => {
+        conn.sftp((err, sftp) => (err ? reject(err) : resolve(sftp)));
+    });
+}
+const HEALTH_CMD = [
+    'echo "HOSTNAME:$(hostname)"',
+    'echo "OS_START"',
+    'cat /etc/os-release 2>/dev/null | head -2 || echo "N/A"',
+    'echo "OS_END"',
+    'echo "UPTIME:$(uptime -p 2>/dev/null || cat /proc/uptime)"',
+    'echo "LOAD:$(cat /proc/loadavg)"',
+    'echo "MEM:$(free -h 2>/dev/null || head -5 /proc/meminfo)"',
+    'echo "DISK_START"',
+    'df -h / /tmp /var 2>/dev/null || df -h /',
+    'echo "DISK_END"',
+    'echo "CPU:$(nproc) cores"',
+].join("; ");
+export async function getHealth(cfg, timeoutMs = 30_000) {
+    const r = await runCommand(cfg, HEALTH_CMD, timeoutMs);
+    const out = (r.stdout || "") + (r.stderr || "");
+    const extract = (label) => {
+        const m = out.match(new RegExp(`${label}:(.+?)(?:\\n|$)`));
+        return m ? m[1].trim() : "—";
+    };
+    const section = (start, end) => {
+        const i = out.indexOf(start);
+        const j = out.indexOf(end, i);
+        if (i === -1)
+            return "—";
+        return out.slice(i + start.length, j === -1 ? undefined : j).trim();
+    };
+    return {
+        server: cfg.name,
+        hostname: extract("HOSTNAME"),
+        os: section("OS_START", "OS_END"),
+        uptime: extract("UPTIME"),
+        load: extract("LOAD"),
+        memory: extract("MEM"),
+        disk: section("DISK_START", "DISK_END"),
+        cpuCores: extract("CPU"),
+    };
+}
+export async function getCertInfo(cfg, host, port = 443, timeoutMs = 15_000) {
+    const cmd = `echo | openssl s_client -connect '${host}:${port}' -servername '${host}' 2>/dev/null | openssl x509 -noout -subject -issuer -dates -fingerprint -ext subjectAltName`;
+    const r = await runCommand(cfg, cmd, timeoutMs);
+    const out = (r.stdout || "") + (r.stderr || "");
+    const extract = (label) => {
+        const m = out.match(new RegExp(`^${label}\\s*=\\s*(.+)$`, "m"));
+        return m ? m[1].trim() : "—";
+    };
+    const sans = [];
+    const sanRe = /DNS:([^\s,]+)/g;
+    let m;
+    while ((m = sanRe.exec(out)))
+        sans.push(m[1]);
+    const notAfter = extract("notAfter");
+    let remainingDays = -1;
+    try {
+        remainingDays = Math.ceil((Date.parse(notAfter) - Date.now()) / 86_400_000);
+    }
+    catch { /* */ }
+    return {
+        subject: extract("subject"),
+        issuer: extract("issuer"),
+        notBefore: extract("notBefore"),
+        notAfter,
+        sans,
+        fingerprint: extract("fingerprint") || extract("SHA256 Fingerprint") || extract("SHA1 Fingerprint"),
+        remainingDays,
+    };
+}
+export async function copyBetween(srcCfg, destCfg, sourcePath, destPath) {
+    const srcConn = await createConnection(srcCfg, 20_000);
+    const srcSftp = await sftpOpen(srcConn);
+    // stat the source file
+    const srcStat = await new Promise((resolve, reject) => {
+        srcSftp.stat(sourcePath, (err, s) => (err ? reject(err) : resolve(s)));
+    });
+    const destConn = await createConnection(destCfg, 20_000);
+    const destSftp = await sftpOpen(destConn);
+    const startedAt = Date.now();
+    await new Promise((resolve, reject) => {
+        const readStream = srcSftp.createReadStream(sourcePath);
+        const writeStream = destSftp.createWriteStream(destPath);
+        readStream.on("error", (err) => {
+            destConn.end();
+            srcConn.end();
+            reject(err);
+        });
+        writeStream.on("error", (err) => {
+            destConn.end();
+            srcConn.end();
+            reject(err);
+        });
+        writeStream.on("close", () => {
+            destConn.end();
+            srcConn.end();
+            resolve();
+        });
+        readStream.pipe(writeStream);
+    });
+    return {
+        sourceServer: srcCfg.name,
+        destServer: destCfg.name,
+        sourcePath,
+        destPath,
+        size: srcStat.size,
+        elapsedMs: Date.now() - startedAt,
+    };
+}
+export async function diffServers(cfgA, cfgB, path) {
+    const read = async (cfg) => {
+        const conn = await createConnection(cfg, 20_000);
+        const sftp = await sftpOpen(conn);
+        return new Promise((resolve, reject) => {
+            let buf = "";
+            const stream = sftp.createReadStream(path, { autoClose: true });
+            stream.on("data", (d) => (buf += d.toString("utf8")));
+            stream.on("error", reject);
+            stream.on("end", () => {
+                conn.end();
+                resolve(buf);
+            });
+        });
+    };
+    const [a, b] = await Promise.all([read(cfgA), read(cfgB)]);
+    const linesA = a.split("\n");
+    const linesB = b.split("\n");
+    // simple unified diff
+    const diffLines = [];
+    const maxLen = Math.max(linesA.length, linesB.length);
+    let added = 0;
+    let removed = 0;
+    // Very simple line-by-line comparison with context
+    let i = 0, j = 0;
+    while (i < linesA.length || j < linesB.length) {
+        if (i < linesA.length && j < linesB.length && linesA[i] === linesB[j]) {
+            diffLines.push(`  ${linesA[i]}`);
+            i++;
+            j++;
+        }
+        else {
+            // look ahead for sync point
+            let syncI = -1, syncJ = -1;
+            const lookahead = 10;
+            for (let di = 0; di <= lookahead && i + di < linesA.length; di++) {
+                for (let dj = 0; dj <= lookahead && j + dj < linesB.length; dj++) {
+                    if (di === 0 && dj === 0)
+                        continue;
+                    if (linesA[i + di] === linesB[j + dj]) {
+                        if (syncI === -1 || di + dj < syncI + syncJ) {
+                            syncI = di;
+                            syncJ = dj;
+                        }
+                    }
+                }
+            }
+            if (syncI >= 0) {
+                // show removed lines from A
+                for (let di = 0; di < syncI; di++) {
+                    diffLines.push(`- ${linesA[i + di]}`);
+                    removed++;
+                }
+                // show added lines from B
+                for (let dj = 0; dj < syncJ; dj++) {
+                    diffLines.push(`+ ${linesB[j + dj]}`);
+                    added++;
+                }
+                i += syncI;
+                j += syncJ;
+            }
+            else {
+                // no sync found, dump remaining
+                while (i < linesA.length) {
+                    diffLines.push(`- ${linesA[i++]}`);
+                    removed++;
+                }
+                while (j < linesB.length) {
+                    diffLines.push(`+ ${linesB[j++]}`);
+                    added++;
+                }
+            }
+        }
+    }
+    return {
+        path,
+        serverA: cfgA.name,
+        serverB: cfgB.name,
+        identical: added === 0 && removed === 0,
+        added,
+        removed,
+        diff: diffLines.join("\n"),
+    };
+}
+export async function execScript(cfg, localScriptPath, remotePath, timeoutMs = 120_000) {
+    const conn = await createConnection(cfg, 20_000);
+    const sftp = await sftpOpen(conn);
+    // upload the script
+    await new Promise((resolve, reject) => {
+        const read = createReadStream(localScriptPath);
+        const write = sftp.createWriteStream(remotePath, { mode: 0o755 });
+        read.on("error", reject);
+        write.on("error", reject);
+        write.on("close", resolve);
+        read.pipe(write);
+    });
+    // run it
+    const result = await runCommand(cfg, `chmod +x '${remotePath}' && '${remotePath}'; EC=$?; rm -f '${remotePath}'; exit $EC`, timeoutMs, undefined);
+    conn.end();
+    return {
+        server: cfg.name,
+        exitCode: result.code,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+export async function snapshot(cfg, remoteDir, localFile, excludes = []) {
+    const startedAt = Date.now();
+    const excludeArgs = excludes.map((e) => `--exclude='${e}'`).join(" ");
+    const cmd = `cd '${remoteDir}' && tar czf - ${excludeArgs} .`;
+    const conn = await createConnection(cfg, 20_000);
+    await new Promise((resolve, reject) => {
+        conn.exec(cmd, (err, stream) => {
+            if (err) {
+                conn.end();
+                return reject(err);
+            }
+            const write = createWriteStream(localFile);
+            stream.on("error", (e) => { conn.end(); reject(e); });
+            write.on("error", (e) => { conn.end(); reject(e); });
+            stream.on("close", (code) => {
+                conn.end();
+                if (code !== null && code !== 0) {
+                    return reject(new Error(`tar 退出码: ${code}`));
+                }
+                resolve();
+            });
+            stream.pipe(write);
+        });
+    });
+    const fileSize = statSync(localFile).size;
+    return {
+        server: cfg.name,
+        remotePath: remoteDir,
+        localFile,
+        fileSize,
+        elapsedMs: Date.now() - startedAt,
+    };
+}
+const tails = new Map();
+let tailCounter = 0;
+export async function startTailFollow(cfg, path, intervalMs = 2000, onData) {
+    const conn = await createConnection(cfg, 20_000);
+    const sftp = await sftpOpen(conn);
+    const currentSize = await new Promise((resolve, reject) => {
+        sftp.stat(path, (err, s) => (err ? reject(err) : resolve(s)));
+    });
+    const id = `tail${++tailCounter}`;
+    let offset = currentSize.size;
+    const tf = {
+        id,
+        server: cfg.name,
+        path,
+        state: "following",
+        seenBytes: 0,
+        createdAt: Date.now(),
+    };
+    const timer = setInterval(() => {
+        if (tf.state === "stopped") {
+            clearInterval(timer);
+            conn.end();
+            tails.delete(id);
+            return;
+        }
+        sftp.stat(path, (err, s) => {
+            if (err)
+                return;
+            if (s.size > offset) {
+                const read = sftp.createReadStream(path, { start: offset, end: s.size - 1 });
+                let chunk = "";
+                read.on("data", (d) => (chunk += d.toString("utf8")));
+                read.on("end", () => {
+                    tf.seenBytes += chunk.length;
+                    offset = s.size;
+                    onData(id, chunk);
+                });
+            }
+            else if (s.size < offset) {
+                // file truncated
+                offset = 0;
+            }
+        });
+    }, intervalMs);
+    tails.set(id, { ...tf, timer });
+    conn.on("close", () => { tf.state = "stopped"; clearInterval(timer); tails.delete(id); });
+    conn.on("error", () => { tf.state = "stopped"; clearInterval(timer); tails.delete(id); });
+    return tf;
+}
+export function stopTailFollow(id) {
+    const t = tails.get(id);
+    if (!t)
+        return false;
+    t.state = "stopped";
+    clearInterval(t.timer);
+    tails.delete(id);
+    return true;
+}
+export function getTailFollow(id) {
+    const t = tails.get(id);
+    if (!t)
+        return undefined;
+    return { id: t.id, server: t.server, path: t.path, state: t.state, seenBytes: t.seenBytes, createdAt: t.createdAt };
+}
+export function listTailFollows() {
+    return [...tails.values()].map((t) => ({
+        id: t.id, server: t.server, path: t.path, state: t.state, seenBytes: t.seenBytes, createdAt: t.createdAt,
+    }));
+}
+export async function httpRequest(cfg, url, method = "GET", headers = {}, body, timeoutMs = 30_000) {
+    const headerArgs = Object.entries(headers)
+        .map(([k, v]) => `-H '${k}: ${v.replace(/'/g, "'\\''")}'`)
+        .join(" ");
+    const dataArg = body ? `--data '${body.replace(/'/g, "'\\''")}'` : "";
+    const urlEscaped = url.replace(/'/g, "'\\''");
+    const cmd = `curl -sS -w '\\n<<HTTP_CODE>>%{http_code}<<TIME>>%{time_total}' -X ${method} ${headerArgs} ${dataArg} '${urlEscaped}'`;
+    const r = await runCommand(cfg, cmd, timeoutMs);
+    const out = (r.stdout || "") + (r.stderr || "");
+    let httpCode = "—";
+    let duration = "—";
+    const codeM = out.match(/<<HTTP_CODE>>(\d+)/);
+    const timeM = out.match(/<<TIME>>([\d.]+)/);
+    if (codeM)
+        httpCode = codeM[1];
+    if (timeM)
+        duration = `${timeM[1]}s`;
+    const bodyContent = out.replace(/<<HTTP_CODE>>\d+.*$/, "").trim();
+    return {
+        server: cfg.name,
+        exitCode: r.code,
+        httpCode,
+        body: bodyContent,
+        headers: "",
+        duration,
+    };
+}
+export async function getRemoteEnv(cfg, processName, timeoutMs = 20_000) {
+    const cmds = [
+        "echo '<<ENV>>'" + "&& env | head -60",
+        "echo '<<USERS>>'" + "&& who 2>/dev/null || echo 'N/A'",
+        "echo '<<OPENFILES>>'" + "&& lsof -u $(whoami) 2>/dev/null | tail -20 || echo 'N/A'",
+        "echo '<<NETWORK>>'" + "&& ss -tlnp 2>/dev/null | head -20 || netstat -tlnp 2>/dev/null | head -20 || echo 'N/A'",
+    ];
+    if (processName) {
+        cmds.push(`echo '<<PROC>>' && ps aux | grep '${processName}' | grep -v grep | head -5`);
+    }
+    const cmd = cmds.join("; ");
+    const r = await runCommand(cfg, cmd, timeoutMs);
+    const out = (r.stdout || "") + (r.stderr || "");
+    const section = (label) => {
+        const i = out.indexOf(`<<${label}>>`);
+        if (i === -1)
+            return "";
+        const start = i + label.length + 7; // <<LABEL>>\n
+        const rest = out.slice(start);
+        const next = rest.search(/<<[A-Z]+>>/);
+        return next === -1 ? rest.trim() : rest.slice(0, next).trim();
+    };
+    const envStr = section("ENV");
+    const envVars = {};
+    for (const line of envStr.split("\n")) {
+        const eq = line.indexOf("=");
+        if (eq > 0)
+            envVars[line.slice(0, eq)] = line.slice(eq + 1);
+    }
+    let procInfo = null;
+    const procSection = section("PROC");
+    if (procSection) {
+        const fields = procSection.split(/\s+/);
+        if (fields.length >= 11) {
+            procInfo = {
+                pid: parseInt(fields[1], 10),
+                ppid: parseInt(fields[2], 10),
+                cmdline: fields.slice(10).join(" "),
+            };
+        }
+    }
+    return {
+        server: cfg.name,
+        envVars,
+        procInfo,
+        users: section("USERS"),
+        openFiles: section("OPENFILES"),
+        network: section("NETWORK"),
+    };
+}
+const watches = new Map();
+let watchCounter = 0;
+export function startWatch(cfg, command, intervalMs, onIteration, timeoutMs = 10_000) {
+    const id = `w${++watchCounter}`;
+    const wh = { id, command, server: cfg.name, intervalMs, state: "running" };
+    let prevOut = "";
+    const tick = async () => {
+        if (wh.state === "stopped") {
+            clearInterval(timer);
+            watches.delete(id);
+            return;
+        }
+        try {
+            const r = await runCommand(cfg, command, timeoutMs);
+            const out = r.stdout + r.stderr;
+            const changed = out !== prevOut;
+            const diff = changed ? computeDiff(prevOut, out) : "";
+            prevOut = out;
+            onIteration(id, {
+                timestamp: Date.now(),
+                stdout: r.stdout,
+                stderr: r.stderr,
+                exitCode: r.code,
+                changed,
+                diff,
+            });
+        }
+        catch {
+            // skip failed iterations
+        }
+    };
+    const timer = setInterval(tick, intervalMs);
+    watches.set(id, { ...wh, timer });
+    // run first iteration immediately
+    tick();
+    return wh;
+}
+export function stopWatch(id) {
+    const w = watches.get(id);
+    if (!w)
+        return false;
+    w.state = "stopped";
+    clearInterval(w.timer);
+    watches.delete(id);
+    return true;
+}
+export function getWatch(id) {
+    return watches.get(id);
+}
+export function listWatches() {
+    return [...watches.values()].map((w) => ({
+        id: w.id, command: w.command, server: w.server, intervalMs: w.intervalMs, state: w.state,
+    }));
+}
+function computeDiff(prev, curr) {
+    const pa = prev.split("\n");
+    const ca = curr.split("\n");
+    const lines = [];
+    const max = Math.max(pa.length, ca.length);
+    for (let i = 0; i < max; i++) {
+        const p = pa[i] ?? "";
+        const c = ca[i] ?? "";
+        if (p !== c) {
+            if (p)
+                lines.push(`- ${p}`);
+            if (c)
+                lines.push(`+ ${c}`);
+        }
+    }
+    return lines.slice(0, 40).join("\n");
+}

package/dist/sftp-ops.js

@@ -0,0 +1,160 @@
+import { posix } from "node:path";
+import { createConnection } from "./ssh.js";
+function openSftp(conn) {
+    return new Promise((resolve, reject) => {
+        conn.sftp((err, sftp) => (err ? reject(err) : resolve(sftp)));
+    });
+}
+function classify(mode) {
+    const ifmt = mode & 0o170000;
+    if (ifmt === 0o040000)
+        return "directory";
+    if (ifmt === 0o100000)
+        return "file";
+    if (ifmt === 0o120000)
+        return "link";
+    return "other";
+}
+function formatMode(mode) {
+    const r = (mode & 0o4) ? "r" : "-";
+    const w = (mode & 0o2) ? "w" : "-";
+    const x = (mode & 0o1) ? "x" : "-";
+    return r + w + x;
+}
+function formatPerms(mode) {
+    const f = classify(mode);
+    const c = f === "directory" ? "d" : f === "link" ? "l" : f === "other" ? "?" : "-";
+    return c + formatMode(mode >> 6) + formatMode(mode >> 3) + formatMode(mode);
+}
+export function formatLsLong(e) {
+    return `${formatPerms(e.mode)}  ${String(e.uid).padStart(5)} ${String(e.gid).padStart(5)}  ${String(e.size).padStart(10)}  ${new Date(e.mtime * 1000).toISOString().replace("T", " ").replace(/\..*/, "")}  ${e.name}`;
+}
+export function formatLsShort(e) {
+    return e.name;
+}
+export async function listDirectory(cfg, path) {
+    const conn = await createConnection(cfg, 20_000);
+    try {
+        const sftp = await openSftp(conn);
+        return new Promise((resolve, reject) => {
+            sftp.readdir(path, (err, entries) => {
+                conn.end();
+                if (err)
+                    return reject(err);
+                resolve(entries.map((e) => ({
+                    name: e.filename,
+                    type: classify(e.attrs.mode),
+                    size: e.attrs.size,
+                    mode: e.attrs.mode,
+                    uid: e.attrs.uid,
+                    gid: e.attrs.gid,
+                    mtime: e.attrs.mtime,
+                    atime: e.attrs.atime,
+                    longname: e.longname,
+                })));
+            });
+        });
+    }
+    catch (e) {
+        conn.end();
+        throw e;
+    }
+}
+export async function statPath(cfg, path) {
+    const conn = await createConnection(cfg, 20_000);
+    try {
+        const sftp = await openSftp(conn);
+        return new Promise((resolve, reject) => {
+            sftp.stat(path, (err, s) => {
+                conn.end();
+                if (err)
+                    return reject(err);
+                resolve({
+                    type: classify(s.mode),
+                    size: s.size,
+                    mode: s.mode,
+                    uid: s.uid,
+                    gid: s.gid,
+                    mtime: s.mtime,
+                    atime: s.atime,
+                });
+            });
+        });
+    }
+    catch (e) {
+        conn.end();
+        throw e;
+    }
+}
+export async function removePath(cfg, path, recursive) {
+    const conn = await createConnection(cfg, 20_000);
+    try {
+        const sftp = await openSftp(conn);
+        // 先 stat 确定类型
+        const s = await new Promise((resolve, reject) => {
+            sftp.stat(path, (err, st) => {
+                if (err)
+                    return reject(err);
+                resolve({ type: classify(st.mode) });
+            });
+        });
+        if (s.type === "directory") {
+            if (!recursive)
+                throw new Error(`"${path}" 是目录，需要 --recursive 选项`);
+            // 递归删除目录内容
+            const entries = await new Promise((res, rej) => {
+                sftp.readdir(path, (err, e) => (err ? rej(err) : res(e)));
+            });
+            for (const e of entries) {
+                if (e.filename === "." || e.filename === "..")
+                    continue;
+                await removePath(cfg, posix.join(path, e.filename), true);
+            }
+            await new Promise((res, rej) => {
+                sftp.rmdir(path, (err) => (err ? rej(err) : res()));
+            });
+        }
+        else {
+            await new Promise((res, rej) => {
+                sftp.unlink(path, (err) => (err ? rej(err) : res()));
+            });
+        }
+        conn.end();
+    }
+    catch (e) {
+        conn.end();
+        throw e;
+    }
+}
+export async function makeDir(cfg, path, parents) {
+    const conn = await createConnection(cfg, 20_000);
+    try {
+        const sftp = await openSftp(conn);
+        if (parents) {
+            // 逐层创建
+            const parts = path.split("/").filter(Boolean);
+            let current = path.startsWith("/") ? "/" : "";
+            for (const p of parts) {
+                current = current ? posix.join(current, p) : p;
+                await new Promise((resolve, reject) => {
+                    sftp.mkdir(current, { mode: 0o755 }, (err) => {
+                        // 已存在不算错
+                        if (err && err.code !== 4)
+                            return reject(err);
+                        resolve();
+                    });
+                });
+            }
+        }
+        else {
+            await new Promise((res, rej) => {
+                sftp.mkdir(path, { mode: 0o755 }, (err) => (err ? rej(err) : res()));
+            });
+        }
+        conn.end();
+    }
+    catch (e) {
+        conn.end();
+        throw e;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bingzi-233/ssh-mcp",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "纯命令行 SSH/SFTP 工具：在多台远程服务器上执行命令、传输大文件（断点续传）。支持 CLI 模式和 MCP stdio 模式。",
   "type": "module",
   "bin": {