mysshx 0.0.0-stage → 1.0.1

package/server/sftpSession.js

@@ -0,0 +1,447 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { WebSocketServer } from 'ws';
+import { getMachine, connectMachine } from './sshManager.js';
+
+const CHUNK = 256 * 1024;
+
+function send(ws, obj) {
+  if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(obj));
+}
+
+function isDir(stats) {
+  if (!stats) return false;
+  if (typeof stats.isDirectory === 'function') return stats.isDirectory();
+  return (stats.mode & 0o170000) === 0o040000;
+}
+
+function isLink(stats) {
+  if (!stats) return false;
+  if (typeof stats.isSymbolicLink === 'function') return stats.isSymbolicLink();
+  return (stats.mode & 0o170000) === 0o120000;
+}
+
+function sortEntries(entries) {
+  entries.sort((a, b) => {
+    if (a.type === 'dir' && b.type !== 'dir') return -1;
+    if (a.type !== 'dir' && b.type === 'dir') return 1;
+    return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
+  });
+}
+
+function posixParent(p) {
+  if (!p || p === '/' || p === '.') return null;
+  const parent = path.posix.dirname(p);
+  return parent === p ? null : parent;
+}
+
+function posixJoin(base, name) {
+  return path.posix.join(base || '.', name);
+}
+
+// ---------- remote helpers ----------
+const statSftp = (sftp, p) => new Promise((res, rej) => sftp.stat(p, (e, s) => (e ? rej(e) : res(s))));
+const readdirSftp = (sftp, p) => new Promise((res, rej) => sftp.readdir(p, (e, l) => (e ? rej(e) : res(l))));
+const mkdirSftp = (sftp, p) => new Promise((res, rej) => sftp.mkdir(p, (e) => (e ? rej(e) : res())));
+const rmdirSftp = (sftp, p) => new Promise((res, rej) => sftp.rmdir(p, (e) => (e ? rej(e) : res())));
+const unlinkSftp = (sftp, p) => new Promise((res, rej) => sftp.unlink(p, (e) => (e ? rej(e) : res())));
+const renameSftp = (sftp, a, b) => new Promise((res, rej) => sftp.rename(a, b, (e) => (e ? rej(e) : res())));
+
+async function mkdirRemoteP(sftp, target) {
+  const parts = String(target).split('/');
+  let cur = String(target).startsWith('/') ? '' : '.';
+  for (const part of parts) {
+    if (!part) continue;
+    cur = cur === '' ? `/${part}` : cur === '.' ? part : `${cur}/${part}`;
+    try {
+      await statSftp(sftp, cur);
+    } catch {
+      try {
+        await mkdirSftp(sftp, cur);
+      } catch {}
+    }
+  }
+}
+
+async function removeRemote(sftp, p) {
+  const stats = await statSftp(sftp, p);
+  if (isDir(stats)) {
+    const list = await readdirSftp(sftp, p);
+    for (const item of list) {
+      if (item.filename === '.' || item.filename === '..') continue;
+      await removeRemote(sftp, posixJoin(p, item.filename));
+    }
+    await rmdirSftp(sftp, p);
+  } else {
+    await unlinkSftp(sftp, p);
+  }
+}
+
+// ---------- listings ----------
+async function listLocal(p) {
+  const abs = path.resolve(p || os.homedir());
+  const dirents = await fsp.readdir(abs, { withFileTypes: true });
+  const entries = await Promise.all(
+    dirents.map(async (d) => {
+      const full = path.join(abs, d.name);
+      let stats = null;
+      try {
+        stats = await fsp.stat(full);
+      } catch {
+        try {
+          stats = await fsp.lstat(full);
+        } catch {}
+      }
+      let type = 'file';
+      if (d.isDirectory()) type = 'dir';
+      else if (d.isSymbolicLink() && stats && stats.isDirectory()) type = 'dir';
+      else if (d.isSymbolicLink()) type = 'link';
+      return { name: d.name, type, size: stats ? stats.size : 0, mtime: stats ? stats.mtimeMs : 0, path: full };
+    })
+  );
+  sortEntries(entries);
+  const parent = path.dirname(abs);
+  return { path: abs, parent: parent === abs ? null : parent, entries };
+}
+
+function listRemote(sftp, p) {
+  return new Promise((resolve, reject) => {
+    const target = p || '.';
+    sftp.readdir(target, (err, list) => {
+      if (err) return reject(err);
+      const entries = [];
+      for (const item of list) {
+        if (item.filename === '.' || item.filename === '..') continue;
+        const attrs = item.attrs || {};
+        const dir = isDir(attrs);
+        const link = !dir && isLink(attrs);
+        entries.push({
+          name: item.filename,
+          type: dir ? 'dir' : link ? 'link' : 'file',
+          size: attrs.size || 0,
+          mtime: (attrs.mtime || 0) * 1000,
+          path: path.posix.join(target, item.filename),
+        });
+      }
+      sortEntries(entries);
+      resolve({ path: target, parent: posixParent(target), entries });
+    });
+  });
+}
+
+// ---------- sizes (for progress totals) ----------
+async function sumSizeLocal(p) {
+  const stats = await fsp.stat(p);
+  if (stats.isDirectory()) {
+    let total = 0;
+    const names = await fsp.readdir(p);
+    for (const n of names) {
+      try {
+        total += await sumSizeLocal(path.join(p, n));
+      } catch {}
+    }
+    return total;
+  }
+  return stats.size;
+}
+
+async function sumSizeRemote(sftp, p) {
+  const stats = await statSftp(sftp, p);
+  if (isDir(stats)) {
+    let total = 0;
+    const list = await readdirSftp(sftp, p);
+    for (const item of list) {
+      if (item.filename === '.' || item.filename === '..') continue;
+      try {
+        total += await sumSizeRemote(sftp, posixJoin(p, item.filename));
+      } catch {}
+    }
+    return total;
+  }
+  return stats.size || 0;
+}
+
+// ---------- transfers ----------
+function publicTransfer(t) {
+  return {
+    id: t.id,
+    name: t.name,
+    direction: t.direction,
+    status: t.status,
+    transferred: t.transferred,
+    total: t.total,
+    error: t.error || null,
+  };
+}
+
+function emitProgress(ws, t, force = false) {
+  const now = Date.now();
+  if (force || now - t._last > 150) {
+    t._last = now;
+    send(ws, { event: 'progress', transfer: publicTransfer(t) });
+  }
+}
+
+function startTransfer(ws, transfers, opts) {
+  const t = {
+    id: crypto.randomUUID(),
+    name: opts.name,
+    direction: opts.direction,
+    status: 'pending',
+    transferred: 0,
+    total: 0,
+    error: null,
+    aborted: false,
+    streams: [],
+    _last: 0,
+  };
+  transfers.set(t.id, t);
+  send(ws, { event: 'transfer-add', transfer: publicTransfer(t) });
+
+  (async () => {
+    try {
+      t.total = await opts.total();
+      t.status = 'active';
+      emitProgress(ws, t, true);
+      await opts.run(t);
+      t.status = t.aborted ? 'cancelled' : 'done';
+    } catch (err) {
+      if (t.aborted) t.status = 'cancelled';
+      else {
+        t.status = 'error';
+        t.error = err.message;
+      }
+    }
+    emitProgress(ws, t, true);
+    send(ws, { event: 'refresh', side: opts.refreshSide, path: opts.refreshPath });
+    setTimeout(() => {
+      transfers.delete(t.id);
+      send(ws, { event: 'transfer-remove', id: t.id });
+    }, 6000);
+  })();
+}
+
+function uploadFile(ws, sftp, t, localPath, remotePath) {
+  return new Promise((resolve, reject) => {
+    const rs = fs.createReadStream(localPath, { highWaterMark: CHUNK });
+    const out = sftp.createWriteStream(remotePath);
+    t.streams.push(rs, out);
+    rs.on('error', reject);
+    out.on('error', reject);
+    rs.on('data', (chunk) => {
+      t.transferred += chunk.length;
+      emitProgress(ws, t);
+    });
+    out.on('close', resolve);
+    rs.pipe(out);
+  });
+}
+
+async function uploadPath(ws, sftp, t, localPath, remotePath) {
+  const stats = await fsp.stat(localPath);
+  if (stats.isDirectory()) {
+    await mkdirRemoteP(sftp, remotePath);
+    const names = await fsp.readdir(localPath);
+    for (const n of names) {
+      if (t.aborted) return;
+      await uploadPath(ws, sftp, t, path.join(localPath, n), posixJoin(remotePath, n));
+    }
+  } else {
+    await uploadFile(ws, sftp, t, localPath, remotePath);
+  }
+}
+
+function downloadFile(ws, sftp, t, remotePath, localPath) {
+  return new Promise((resolve, reject) => {
+    const rs = sftp.createReadStream(remotePath);
+    const out = fs.createWriteStream(localPath);
+    t.streams.push(rs, out);
+    rs.on('error', reject);
+    out.on('error', reject);
+    rs.on('data', (chunk) => {
+      t.transferred += chunk.length;
+      emitProgress(ws, t);
+    });
+    out.on('close', resolve);
+    rs.pipe(out);
+  });
+}
+
+function downloadPath(ws, sftp, t, remotePath, localPath) {
+  return new Promise((resolve, reject) => {
+    sftp.stat(remotePath, async (err, stats) => {
+      if (err) return reject(err);
+      try {
+        if (isDir(stats)) {
+          await fsp.mkdir(localPath, { recursive: true });
+          const list = await readdirSftp(sftp, remotePath);
+          for (const item of list) {
+            if (item.filename === '.' || item.filename === '..') continue;
+            if (t.aborted) return resolve();
+            await downloadPath(ws, sftp, t, posixJoin(remotePath, item.filename), path.join(localPath, item.filename));
+          }
+          resolve();
+        } else {
+          await downloadFile(ws, sftp, t, remotePath, localPath);
+          resolve();
+        }
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+
+// ---------- websocket ----------
+export function attachSftp(server) {
+  const wss = new WebSocketServer({ noServer: true });
+
+  server.on('upgrade', (req, socket, head) => {
+    const url = new URL(req.url, 'http://localhost');
+    const match = url.pathname.match(/^\/ws\/sftp\/([^/]+)$/);
+    if (!match) return;
+    wss.handleUpgrade(req, socket, head, (ws) => handle(ws, decodeURIComponent(match[1])));
+  });
+}
+
+async function handle(ws, machineId) {
+  const machine = getMachine(machineId);
+  if (!machine) {
+    send(ws, { event: 'fatal', message: '机器不存在' });
+    return ws.close();
+  }
+
+  let client;
+  let sftp;
+  try {
+    client = await connectMachine(machine);
+    sftp = await new Promise((resolve, reject) => client.sftp((e, s) => (e ? reject(e) : resolve(s))));
+  } catch (err) {
+    send(ws, { event: 'fatal', message: `连接失败: ${err.message}` });
+    try {
+      client && client.end();
+    } catch {}
+    return ws.close();
+  }
+
+  let remoteHome = '.';
+  try {
+    remoteHome = await new Promise((resolve, reject) => sftp.realpath('.', (e, p) => (e ? reject(e) : resolve(p))));
+  } catch {}
+
+  const transfers = new Map();
+  send(ws, { event: 'ready', name: machine.name, localHome: os.homedir(), remoteHome });
+
+  ws.on('message', (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    dispatch(msg).catch((err) => {
+      send(ws, { event: 'error', message: err.message, action: msg.action, side: msg.side, path: msg.path });
+    });
+  });
+
+  ws.on('close', () => {
+    for (const t of transfers.values()) {
+      t.aborted = true;
+      for (const s of t.streams) {
+        try {
+          s.destroy();
+        } catch {}
+      }
+    }
+    try {
+      client.end();
+    } catch {}
+  });
+
+  async function dispatch(msg) {
+    switch (msg.action) {
+      case 'list': {
+        const pane = msg.side === 'local' ? await listLocal(msg.path) : await listRemote(sftp, msg.path);
+        send(ws, { event: 'list', side: msg.side, ...pane });
+        break;
+      }
+      case 'mkdir': {
+        if (msg.side === 'local') {
+          await fsp.mkdir(path.join(msg.parent, msg.name));
+        } else {
+          await mkdirSftp(sftp, posixJoin(msg.parent, msg.name));
+        }
+        await relist(msg.side, msg.parent);
+        break;
+      }
+      case 'rename': {
+        if (msg.side === 'local') {
+          await fsp.rename(msg.path, path.join(path.dirname(msg.path), msg.newName));
+        } else {
+          await renameSftp(sftp, msg.path, posixJoin(posixParent(msg.path) || '.', msg.newName));
+        }
+        await relist(msg.side, msg.side === 'local' ? path.dirname(msg.path) : posixParent(msg.path));
+        break;
+      }
+      case 'delete': {
+        for (const p of msg.paths || []) {
+          if (msg.side === 'local') await fsp.rm(p, { recursive: true, force: true });
+          else await removeRemote(sftp, p);
+        }
+        await relist(msg.side, msg.parent);
+        break;
+      }
+      case 'upload': {
+        for (const localPath of msg.paths || []) {
+          const remotePath = posixJoin(msg.remoteDir, path.basename(localPath));
+          startTransfer(ws, transfers, {
+            name: path.basename(localPath),
+            direction: 'upload',
+            refreshSide: 'remote',
+            refreshPath: msg.remoteDir,
+            total: () => sumSizeLocal(localPath),
+            run: (t) => uploadPath(ws, sftp, t, localPath, remotePath),
+          });
+        }
+        break;
+      }
+      case 'download': {
+        for (const remotePath of msg.paths || []) {
+          const localPath = path.join(msg.localDir, path.posix.basename(remotePath));
+          startTransfer(ws, transfers, {
+            name: path.posix.basename(remotePath),
+            direction: 'download',
+            refreshSide: 'local',
+            refreshPath: msg.localDir,
+            total: () => sumSizeRemote(sftp, remotePath),
+            run: (t) => downloadPath(ws, sftp, t, remotePath, localPath),
+          });
+        }
+        break;
+      }
+      case 'cancel': {
+        const t = transfers.get(msg.id);
+        if (t) {
+          t.aborted = true;
+          for (const s of t.streams) {
+            try {
+              s.destroy();
+            } catch {}
+          }
+        }
+        break;
+      }
+      default:
+        throw new Error(`未知操作: ${msg.action}`);
+    }
+  }
+
+  async function relist(side, p) {
+    const target = side === 'local' ? p || os.homedir() : p || remoteHome;
+    const pane = side === 'local' ? await listLocal(target) : await listRemote(sftp, target);
+    send(ws, { event: 'list', side, ...pane });
+  }
+}

package/server/sshManager.js

@@ -0,0 +1,61 @@
+import { Client } from 'ssh2';
+import db from './db.js';
+import { decrypt } from './crypto.js';
+
+export function getMachine(id) {
+  return db.prepare('SELECT * FROM machines WHERE id = ?').get(id);
+}
+
+function buildConfig(machine) {
+  const config = {
+    host: machine.host,
+    port: machine.port || 22,
+    username: machine.username,
+    readyTimeout: 20000,
+    keepaliveInterval: 15000,
+    tryKeyboard: true,
+  };
+
+  const privateKey = decrypt(machine.private_key);
+  const passphrase = decrypt(machine.passphrase);
+  const password = decrypt(machine.password);
+
+  if (privateKey) {
+    config.privateKey = privateKey;
+    if (passphrase) config.passphrase = passphrase;
+  }
+  if (password) config.password = password;
+
+  return { config, password };
+}
+
+export function connectMachine(machine) {
+  return new Promise((resolve, reject) => {
+    const client = new Client();
+    const { config, password } = buildConfig(machine);
+    let settled = false;
+    const done = (err, value) => {
+      if (settled) return;
+      settled = true;
+      err ? reject(err) : resolve(value);
+    };
+
+    client.on('keyboard-interactive', (name, instructions, lang, prompts, finish) => {
+      finish(prompts.map(() => password || ''));
+    });
+    client.on('ready', () => done(null, client));
+    client.on('error', (err) => done(err));
+
+    try {
+      client.connect(config);
+    } catch (err) {
+      done(err);
+    }
+  });
+}
+
+export async function testConnection(machine) {
+  const client = await connectMachine(machine);
+  client.end();
+  return true;
+}

package/server/terminalSession.js

@@ -0,0 +1,94 @@
+import { WebSocketServer } from 'ws';
+import { getMachine, connectMachine } from './sshManager.js';
+
+function send(ws, obj) {
+  if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(obj));
+}
+
+export function attachTerminal(server) {
+  const wss = new WebSocketServer({ noServer: true });
+
+  server.on('upgrade', (req, socket, head) => {
+    const url = new URL(req.url, 'http://localhost');
+    const match = url.pathname.match(/^\/ws\/terminal\/([^/]+)$/);
+    if (!match) return;
+    wss.handleUpgrade(req, socket, head, (ws) => handle(ws, decodeURIComponent(match[1])));
+  });
+}
+
+async function handle(ws, machineId) {
+  const machine = getMachine(machineId);
+  if (!machine) {
+    send(ws, { type: 'error', message: '机器不存在' });
+    return ws.close();
+  }
+
+  let stream = null;
+  const pending = [];
+
+  const applyMessage = (msg) => {
+    if (!stream) return;
+    if (msg.type === 'input' && msg.data) {
+      stream.write(Buffer.from(msg.data, 'base64'));
+    } else if (msg.type === 'resize' && stream.setWindow) {
+      const cols = Math.max(1, msg.cols | 0);
+      const rows = Math.max(1, msg.rows | 0);
+      stream.setWindow(rows, cols, 0, 0);
+    }
+  };
+
+  ws.on('message', (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    if (stream) applyMessage(msg);
+    else pending.push(msg);
+  });
+
+  let client;
+  try {
+    client = await connectMachine(machine);
+  } catch (err) {
+    send(ws, { type: 'error', message: `连接失败: ${err.message}` });
+    return ws.close();
+  }
+
+  client.shell(
+    { term: 'xterm-256color', cols: 80, rows: 24 },
+    (err, s) => {
+      if (err) {
+        send(ws, { type: 'error', message: `打开终端失败: ${err.message}` });
+        try {
+          client.end();
+        } catch {}
+        return ws.close();
+      }
+
+      stream = s;
+      for (const msg of pending) applyMessage(msg);
+      pending.length = 0;
+
+      send(ws, { type: 'status', status: 'connected', name: machine.name });
+
+      const push = (data) => send(ws, { type: 'data', data: data.toString('base64') });
+      stream.on('data', push);
+      if (stream.stderr) stream.stderr.on('data', push);
+      stream.on('close', (code) => {
+        send(ws, { type: 'status', status: 'closed', code });
+        try {
+          client.end();
+        } catch {}
+        ws.close();
+      });
+    }
+  );
+
+  ws.on('close', () => {
+    try {
+      client.end();
+    } catch {}
+  });
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.