@sstar/embedlink_agent 0.1.0

package/dist/ssh/adapter.js

@@ -0,0 +1,126 @@
+import { execRemoteRaw } from '../server/web.js';
+export class SSHAdapter {
+    constructor(client) {
+        this.systemType = null;
+        this.homeDir = null;
+        this.client = client;
+    }
+    // 系统检测 - 一次检测，全程使用
+    async init() {
+        await this.detectSystem();
+        await this.detectHomeDir();
+    }
+    async detectSystem() {
+        try {
+            // 一个命令就能检测系统类型：Unix系统有uname命令，Windows没有
+            const result = await this.exec(`uname >/dev/null 2>&1 && echo "unix" || echo "windows"`);
+            this.systemType = result.trim() === 'unix' ? 'unix' : 'windows';
+        }
+        catch {
+            // 如果检测失败，默认为unix（更常见）
+            this.systemType = 'unix';
+        }
+    }
+    async detectHomeDir() {
+        try {
+            if (this.systemType === 'unix') {
+                this.homeDir = (await this.exec('echo "${HOME:-/tmp}"')).trim();
+            }
+            else {
+                this.homeDir = (await this.exec('echo %USERPROFILE%')).trim();
+            }
+        }
+        catch {
+            // 检测失败时的fallback
+            this.homeDir = this.systemType === 'unix' ? '/tmp' : 'C:\\temp';
+        }
+    }
+    // 核心执行方法 - 统一错误处理
+    async exec(command) {
+        return execRemoteRaw(this.client, command);
+    }
+    // 文件操作 - 自动使用正确的命令和路径
+    async fileExists(path) {
+        const cmd = this.systemType === 'unix'
+            ? `test -f "${path}" && echo "EXISTS"`
+            : `if exist "${path.replace(/\//g, '\\')}" echo EXISTS`;
+        const result = await this.exec(cmd);
+        return result.trim() === 'EXISTS';
+    }
+    async readFile(path) {
+        const cmd = this.systemType === 'unix' ? `cat "${path}"` : `type "${path.replace(/\//g, '\\')}"`;
+        return await this.exec(cmd);
+    }
+    async writeFile(path, content) {
+        // 统一使用base64方式，避免转义问题
+        const base64 = Buffer.from(content).toString('base64');
+        const tempFile = `${path}.tmp.${Date.now()}`;
+        if (this.systemType === 'unix') {
+            await this.exec(`echo '${base64}' | base64 -d > "${tempFile}"`);
+            await this.exec(`mv "${tempFile}" "${path}"`);
+        }
+        else {
+            const winPath = path.replace(/\//g, '\\');
+            const winTemp = tempFile.replace(/\//g, '\\');
+            await this.exec(`echo ${base64} > "${winTemp}.b64"`);
+            try {
+                await this.exec(`certutil -decode "${winTemp}.b64" "${winPath}"`);
+            }
+            catch {
+                // certutil失败时使用powershell
+                await this.exec(`powershell -Command "[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${base64}'))" > "${winPath}"`);
+            }
+            await this.exec(`del /f /q "${winTemp}.b64" 2>nul`);
+        }
+    }
+    async mkdir(path) {
+        const cmd = this.systemType === 'unix'
+            ? `mkdir -p "${path}"`
+            : `if not exist "${path.replace(/\//g, '\\')}" mkdir "${path.replace(/\//g, '\\')}"`;
+        await this.exec(cmd);
+    }
+    // 网络检测 - 统一接口
+    async isPortListening(port) {
+        const cmd = this.systemType === 'unix'
+            ? `netstat -an 2>/dev/null | grep :${port} | grep LISTEN || ss -ltn 2>/dev/null | grep :${port}`
+            : `netstat -an | findstr :${port}`;
+        const result = await this.exec(cmd);
+        return result.includes(`:${port}`);
+    }
+    // 路径处理 - 自动使用正确分隔符
+    joinPath(...parts) {
+        if (this.systemType === 'windows') {
+            return parts.join('\\');
+        }
+        return parts.join('/');
+    }
+    getConfigDir() {
+        if (!this.homeDir)
+            throw new Error('Adapter not initialized');
+        return this.joinPath(this.homeDir, '.config', 'embed_link');
+    }
+    getAgentJsonPath() {
+        return this.joinPath(this.getConfigDir(), 'agent.json');
+    }
+    // 高级操作 - 组合基础操作
+    async readAgentJson() {
+        const agentJsonPath = this.getAgentJsonPath();
+        if (!(await this.fileExists(agentJsonPath))) {
+            return null;
+        }
+        const content = await this.readFile(agentJsonPath);
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeAgentJson(data) {
+        const configDir = this.getConfigDir();
+        await this.mkdir(configDir);
+        const agentJsonPath = this.getAgentJsonPath();
+        const content = JSON.stringify(data, null, 2);
+        await this.writeFile(agentJsonPath, content);
+    }
+}

package/dist/ssh/candidates.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { exec } from 'node:child_process';
+import dns from 'node:dns/promises';
+export async function gatherSshCandidates() {
+    const hosts = [];
+    // ~/.ssh/config
+    try {
+        const file = await fs.readFile(path.join(os.homedir(), '.ssh', 'config'), 'utf8');
+        const lines = file.split(/\r?\n/);
+        let current = null;
+        for (const line of lines) {
+            const mHost = line.match(/^\s*Host\s+(.+)/i);
+            if (mHost) {
+                current = { host: mHost[1].trim(), hostName: undefined };
+                continue;
+            }
+            const mName = line.match(/^\s*HostName\s+(.+)/i);
+            if (mName && current) {
+                current.hostName = mName[1].trim();
+                hosts.push({
+                    label: current.host,
+                    host: current.hostName || current.host,
+                    configSource: 'ssh-config',
+                });
+                current = null;
+            }
+        }
+    }
+    catch { }
+    // netstat/ss to detect active ssh peers
+    try {
+        const cmd = process.platform === 'win32'
+            ? 'netstat -na'
+            : process.platform === 'darwin'
+                ? 'netstat -an'
+                : 'ss -tn';
+        const out = await execAsync(cmd, 2500);
+        const re = /([0-9]{1,3}(?:\.[0-9]{1,3}){3}):22/gi;
+        const ips = new Set();
+        let m;
+        while ((m = re.exec(out)))
+            ips.add(m[1]);
+        for (const ip of ips) {
+            const label = await reverseOrIp(ip, 800);
+            hosts.push({
+                label,
+                host: ip,
+                configSource: 'manual',
+            });
+        }
+    }
+    catch { }
+    return hosts;
+}
+async function reverseOrIp(ip, timeoutMs) {
+    try {
+        const p = dns.reverse(ip);
+        const r = (await Promise.race([
+            p,
+            new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), timeoutMs)),
+        ]));
+        if (Array.isArray(r) && r.length)
+            return r[0];
+    }
+    catch { }
+    return ip;
+}
+function execAsync(cmd, timeoutMs = 3000) {
+    return new Promise((resolve, reject) => {
+        const p = exec(cmd, { windowsHide: true }, (err, stdout, stderr) => {
+            if (err)
+                return reject(err);
+            resolve(String(stdout || stderr || ''));
+        });
+        setTimeout(() => {
+            try {
+                p.kill();
+            }
+            catch { }
+            reject(new Error('timeout'));
+        }, timeoutMs);
+    });
+}

package/dist/ssh/index.js

@@ -0,0 +1,3 @@
+export { SSHAdapter } from './adapter.js';
+export { SshTunnel } from './tunnel.js';
+export { gatherSshCandidates } from './candidates.js';

package/dist/ssh/paircheck.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { credentials, loadPackageDefinition } from '@grpc/grpc-js';
+import { loadSync } from '@grpc/proto-loader';
+export function createAgentPairingClient(addr) {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.join(here, '..', '..', 'proto', 'agent.proto'),
+        path.join(here, '..', '..', '..', 'proto', 'agent.proto'),
+    ];
+    const protoPath = candidates.find((p) => fs.existsSync(p)) || candidates[0];
+    const def = loadSync(protoPath, {
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true,
+        keepCase: true,
+    });
+    const pkg = loadPackageDefinition(def);
+    const Cls = pkg.embedlink.agent.v1.PairingService;
+    const client = new Cls(addr, credentials.createInsecure());
+    return {
+        pairCheck(req) {
+            return new Promise((resolve, reject) => {
+                const payload = {
+                    pairCode: req.pairCode,
+                    clientId: req.clientId || '',
+                    timestamp: Date.now(),
+                };
+                client.PairCheck(payload, (e, r) => (e ? reject(e) : resolve(r)));
+            });
+        },
+    };
+}

package/dist/ssh/tunnel.js

@@ -0,0 +1,111 @@
+import { Client } from 'ssh2';
+import net from 'node:net';
+import { error, ErrorCodes } from '../core/errors.js';
+export class SshTunnel {
+    constructor() {
+        this.client = new Client();
+        this.connected = false;
+    }
+    /**
+     * 验证SSH隧道的连通性
+     * 通过SSH连接执行一个简单的本地端口连通性测试
+     */
+    async verifyConnectivity(timeoutMs = 3000) {
+        if (!this.connected || !this.opts)
+            return false;
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                resolve(false); // 超时视为不可用
+            }, timeoutMs);
+            // 尝试通过SSH连接到本地目标端口
+            const conn = net.connect(this.opts.dstPort, this.opts.dstHost);
+            conn.on('connect', () => {
+                clearTimeout(timer);
+                conn.destroy();
+                resolve(true);
+            });
+            conn.on('error', () => {
+                clearTimeout(timer);
+                resolve(false);
+            });
+            conn.setTimeout(timeoutMs);
+        });
+    }
+    start(opts) {
+        return new Promise((resolve, reject) => {
+            this.opts = opts;
+            this.client
+                .on('ready', () => {
+                this.client.forwardIn(opts.bindAddr, opts.bindPort, (err) => {
+                    if (err)
+                        return reject(err);
+                    this.client.on('tcp connection', (info, accept, rejectTcp) => {
+                        const stream = accept();
+                        const socket = net.connect(opts.dstPort, opts.dstHost);
+                        stream.on('error', () => {
+                            try {
+                                socket.destroy();
+                            }
+                            catch { }
+                        });
+                        socket.on('error', () => {
+                            try {
+                                stream.end();
+                            }
+                            catch { }
+                        });
+                        stream.pipe(socket).pipe(stream);
+                    });
+                    this.connected = true;
+                    resolve({ bindPort: opts.bindPort });
+                });
+            })
+                .on('error', (e) => reject(error(ErrorCodes.EL_SSH_CONNECT_FAILED, String(e))))
+                .connect({
+                host: opts.host,
+                port: opts.port,
+                username: opts.user,
+                password: opts.password,
+                privateKey: opts.privateKey,
+                tryKeyboard: false,
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            // Set connected to false immediately
+            this.connected = false;
+            try {
+                // Add proper cleanup handlers
+                this.client.on('end', () => {
+                    resolve();
+                });
+                this.client.on('error', () => {
+                    resolve(); // Even error should resolve the promise
+                });
+                // Set a timeout to ensure we don't hang forever
+                const timeout = setTimeout(() => {
+                    resolve(); // Force resolve after timeout
+                }, 3000);
+                this.client.on('end', () => {
+                    clearTimeout(timeout);
+                });
+                this.client.on('error', () => {
+                    clearTimeout(timeout);
+                });
+                // End the connection
+                this.client.end();
+            }
+            catch (e) {
+                // If something goes wrong, still resolve
+                resolve();
+            }
+        });
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getClient() {
+        return this.client;
+    }
+}