wative 1.2.7 → 1.2.10

package/src/ssh/client.ts

@@ -1,389 +0,0 @@
-import { Client } from 'ssh2';
-import { readFileSync } from 'fs';
-
-
-export interface SSHAuthConfig {
-  username: string;
-  privateKeyPath: string;
-  publicKeyPath: string;
-  passphrase?: string;
-}
-
-export interface SSHConfig {
-  // Wative service configuration
-  host: string;
-  port: number;
-
-  // Optional: specific client authentication for Wative service
-  // If not provided, will use the main auth configuration
-  clientAuth: SSHAuthConfig;
-
-  // Remote server deployment support
-  useRemoteServer?: boolean;
-  remoteServer?: {
-    host: string;
-    port?: number;
-    auth: SSHAuthConfig;
-  };
-}
-
-export interface WativeRequest {
-  method: string;
-  keystoreId?: string;
-  chainId?: string;
-  params?: any;
-}
-
-export interface WativeResponse {
-  status: boolean;
-  data?: any;
-  msg?: string;
-}
-
-export class WativeSSHClient {
-  private config: SSHConfig;
-
-  constructor(config: SSHConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Execute a command on the SSH server
-   * @param command The command to execute
-   * @returns Promise<string> The command output
-   */
-  private async executeCommand(command: string): Promise<string> {
-    if (this.config.useRemoteServer) {
-      return this.executeCommandThroughRemoteServer(command);
-    }
-
-
-
-    return new Promise((resolve, reject) => {
-      const conn = new Client();
-
-      conn.on('ready', () => {
-        conn.exec(command, (err, stream) => {
-          if (err) {
-            conn.end();
-            return reject(err);
-          }
-
-          let output = '';
-          let errorOutput = '';
-
-          stream.on('close', (code: number, signal: string) => {
-            conn.end();
-            if (code === 0) {
-              resolve(output);
-            } else {
-              reject(new Error(`Command failed with code ${code}: ${errorOutput || output}`));
-            }
-          }).on('data', (data: Buffer) => {
-            output += data.toString();
-          }).stderr.on('data', (data: Buffer) => {
-            errorOutput += data.toString();
-          });
-        });
-      }).on('error', (err) => {
-        reject(err);
-      });
-
-      // Connect with public key authentication
-      const authConfig = this.config.clientAuth;
-      const connectOptions: any = {
-        host: this.config.host,
-        port: this.config.port,
-        username: authConfig.username,
-        privateKey: readFileSync(authConfig.privateKeyPath),
-        passphrase: authConfig.passphrase
-      };
-
-      conn.connect(connectOptions);
-    });
-  }
-
-  /**
-   * Execute a command through remote server
-   * @param command The command to execute
-   * @returns Promise<string> The command output
-   */
-  private async executeCommandThroughRemoteServer(command: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const remoteConn = new Client();
-
-      remoteConn.on('ready', () => {
-        // Create a tunnel through remote server to Wative service
-        remoteConn.forwardOut(
-          '127.0.0.1', 0, // source
-          this.config.host, this.config.port, // destination (Wative service)
-          (err, stream) => {
-            if (err) {
-              remoteConn.end();
-              return reject(err);
-            }
-
-            // Create connection to Wative service through tunnel
-            const wativeConn = new Client();
-
-            wativeConn.on('ready', () => {
-              wativeConn.exec(command, (err, execStream) => {
-                if (err) {
-                  wativeConn.end();
-                  remoteConn.end();
-                  return reject(err);
-                }
-
-                let output = '';
-                let errorOutput = '';
-
-                execStream.on('close', (code: number, signal: string) => {
-                  wativeConn.end();
-                  remoteConn.end();
-                  if (code === 0) {
-                    resolve(output);
-                  } else {
-                    reject(new Error(`Command failed with code ${code}: ${errorOutput || output}`));
-                  }
-                }).on('data', (data: Buffer) => {
-                  output += data.toString();
-                }).stderr.on('data', (data: Buffer) => {
-                  errorOutput += data.toString();
-                });
-              });
-            }).on('error', (err) => {
-              remoteConn.end();
-              reject(err);
-            });
-
-            // Connect to Wative service through tunnel using client keys
-            const clientAuth = this.config.clientAuth;
-            const wativeConnectOptions: any = {
-              sock: stream,
-              username: clientAuth.username,
-              privateKey: readFileSync(clientAuth.privateKeyPath),
-              passphrase: clientAuth.passphrase
-            };
-
-            wativeConn.connect(wativeConnectOptions);
-          }
-        );
-      }).on('error', (err) => {
-        reject(err);
-      });
-
-      // Connect to remote server using remote server keys
-      const remoteConnectOptions: any = {
-        host: this.config.remoteServer!.host,
-        port: this.config.remoteServer!.port || 22,
-        username: this.config.remoteServer!.auth.username,
-        privateKey: readFileSync(this.config.remoteServer!.auth.privateKeyPath),
-        passphrase: this.config.remoteServer!.auth.passphrase
-      };
-
-      remoteConn.connect(remoteConnectOptions);
-    });
-  }
-
-
-
-  /**
-   * Send a request to the Wative server
-   * @param request The request object
-   * @returns Promise<WativeResponse> The server response
-   */
-  async sendRequest(request: WativeRequest): Promise<WativeResponse> {
-    try {
-      const command = JSON.stringify(request);
-
-      const output = await this.executeCommand(command);
-
-      // Parse the JSON response
-      const response: WativeResponse = JSON.parse(output);
-
-      if (!response.status) {
-        throw new Error(response.msg || 'Request failed');
-      }
-
-      return response;
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`SSH request failed: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Get root account for a keystore and chain
-   * @param keystoreId The keystore ID
-   * @param chainId The chain ID
-   * @returns Promise<any> The root account data
-   */
-  async getRootAccount(keystoreId: string, chainId: string): Promise<any> {
-    const request: WativeRequest = {
-      method: 'get_root_account',
-      keystoreId,
-      chainId
-    };
-
-    const response = await this.sendRequest(request);
-    return response.data;
-  }
-
-  /**
-   * Get sub accounts for a keystore and chain
-   * @param keystoreId The keystore ID
-   * @param chainId The chain ID
-   * @param startIndex Optional start index
-   * @param endIndex Optional end index
-   * @returns Promise<any> The sub account data
-   */
-  async getSubAccount(keystoreId: string, chainId: string, startIndex?: number, endIndex?: number): Promise<any> {
-    const request: WativeRequest = {
-      method: 'get_sub_account',
-      params: {
-        keystoreId,
-        chainId,
-        startIndex,
-        endIndex
-      }
-    };
-
-    const response = await this.sendRequest(request);
-    return response.data;
-  }
-
-  /**
-   * Sign a transaction
-   * @param txParams Transaction parameters
-   * @param rpcUrl RPC URL
-   * @returns Promise<any> The signed transaction
-   */
-  async signTransaction(txParams: any, rpcUrl: string): Promise<any> {
-    const request: WativeRequest = {
-      method: 'sign',
-      params: {
-        txParams,
-        rpcUrl
-      }
-    };
-
-    const response = await this.sendRequest(request);
-    return response.data;
-  }
-
-  /**
-   * Sign and send a transaction
-   * @param txParams Transaction parameters
-   * @param rpcUrl RPC URL
-   * @returns Promise<any> The transaction hash
-   */
-  async signAndSendTransaction(txParams: any, rpcUrl: string): Promise<any> {
-    const request: WativeRequest = {
-      method: 'sign_and_send',
-      params: {
-        txParams,
-        rpcUrl
-      }
-    };
-
-    const response = await this.sendRequest(request);
-    return response.data;
-  }
-
-  /**
-   * Sign a Solana transaction
-   * @param txParams Transaction parameters
-   * @param rpcUrl RPC URL
-   * @param priorityFee Priority fee
-   * @returns Promise<any> The signed transaction
-   */
-  async signSolanaTransaction(txParams: any, rpcUrl: string, priorityFee?: any): Promise<any> {
-    const request: WativeRequest = {
-      method: 'solana_sign',
-      params: {
-        txParams,
-        rpcUrl,
-        priority_fee: priorityFee
-      }
-    };
-
-    const response = await this.sendRequest(request);
-    return response.data;
-  }
-
-  /**
-   * Send a signed Solana transaction
-   * @param txParams Transaction parameters with signature
-   * @param rpcUrl RPC URL
-   * @returns Promise<any> The transaction result
-   */
-  async sendSignedSolanaTransaction(txParams: any, rpcUrl: string): Promise<any> {
-    const request: WativeRequest = {
-      method: 'solana_send',
-      params: {
-        txParams,
-        rpcUrl
-      }
-    };
-
-    const response = await this.sendRequest(request);
-    return response.data;
-  }
-
-  /**
-   * Sign a message
-   * @param account The account to sign with
-   * @param message The message to sign
-   * @returns Promise<any> The signature
-   */
-  async signMessage(account: string, message: string): Promise<any> {
-    const request: WativeRequest = {
-      method: 'sign_message',
-      params: {
-        account,
-        message
-      }
-    };
-
-    const response = await this.sendRequest(request);
-    return response.data;
-  }
-
-  /**
-   * Sign typed data (EIP-712)
-   * @param account The account to sign with
-   * @param domain The domain
-   * @param typesName The types name
-   * @param types The types
-   * @param message The message
-   * @returns Promise<any> The signature
-   */
-  async signTypedData(account: string, domain: string, typesName: string, types: string, message: string): Promise<any> {
-    const request: WativeRequest = {
-      method: 'sign_typed_data',
-      params: {
-        account,
-        domain,
-        types_name: typesName,
-        types,
-        message
-      }
-    };
-
-    const response = await this.sendRequest(request);
-    return response.data;
-  }
-}
-
-/**
- * Create a new Wative SSH client instance
- * @param config SSH configuration
- * @returns WativeSSHClient instance
- */
-export function createWativeSSHClient(config: SSHConfig): WativeSSHClient {
-  return new WativeSSHClient(config);
-}
-
-export default WativeSSHClient;

package/src/ssh/config_manager.ts

@@ -1,304 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as ini from 'ini';
-import * as crypto from 'crypto';
-import { SSHServiceConfig } from './types';
-import { execSync } from 'child_process';
-
-export class SSHConfigManager {
-    private configDir: string;
-    private keystorePath: string;
-
-    constructor(configDir?: string, keystorePath?: string) {
-        this.configDir = configDir || path.join(require('os').homedir(), '.wative/ssh');
-        this.keystorePath = keystorePath || path.join(require('os').homedir(), '.wative');
-        
-        if (!fs.existsSync(this.configDir)) {
-            fs.mkdirSync(this.configDir, { recursive: true });
-        }
-        
-        // Create conf.d directory for service configurations
-        const confDir = path.join(this.configDir, 'conf.d');
-        if (!fs.existsSync(confDir)) {
-            fs.mkdirSync(confDir, { recursive: true });
-        }
-    }
-
-    /**
-     * 获取 keystore 路径
-     */
-    public getKeystorePath(): string {
-        return this.keystorePath;
-    }
-
-    /**
-     * 获取配置目录路径
-     */
-    public getConfigDir(): string {
-        return this.configDir;
-    }
-
-    /**
-     * 创建新的 SSH 服务配置
-     */
-    public async createServiceConfig(
-        serviceName: string,
-        port: number,
-        allowedKeystores: string[],
-        clientName: string = 'default_client',
-        description?: string
-    ): Promise<SSHServiceConfig> {
-        // 验证服务名称
-        if (!this.isValidServiceName(serviceName)) {
-            throw new Error('Invalid service name. Use only alphanumeric characters, hyphens, and underscores.');
-        }
-
-        // 检查端口是否已被使用
-        if (this.isPortInUse(port)) {
-            throw new Error(`Port ${port} is already in use by another service.`);
-        }
-
-        // 生成服务专用的密钥对
-        const serverKeyPaths = await this.generateServiceKeyPair(serviceName);
-        const clientKeyPaths = await this.generateClientKeyPair(serviceName, clientName);
-
-        const config: SSHServiceConfig = {
-            name: serviceName,
-            description: description || `Wative SSH Service - ${serviceName}`,
-            ssh: {
-                listen: '127.0.0.1',
-                port: port,
-                log: {
-                    size: 10485760,
-                    backups: 3
-                }
-            },
-            keystore: {
-                path: this.keystorePath,
-                allowed_keystores: allowedKeystores
-            },
-            clients: [{
-                name: clientName,
-                public_key_path: clientKeyPaths.publicKey,
-                allowed_keystores: allowedKeystores
-            }],
-            server_keys: {
-                private_key_path: serverKeyPaths.privateKey,
-                passphrase: serverKeyPaths.passphrase
-            }
-        };
-
-        // 保存配置文件
-        this.saveServiceConfig(serviceName, config);
-        
-        return config;
-    }
-
-    /**
-     * 加载服务配置
-     */
-    public loadServiceConfig(serviceName: string): SSHServiceConfig {
-        const configPath = this.getServiceConfigPath(serviceName);
-        
-        if (!fs.existsSync(configPath)) {
-            throw new Error(`Service configuration '${serviceName}' not found.`);
-        }
-
-        const configData = ini.parse(fs.readFileSync(configPath, 'utf-8'));
-        return this.parseConfigData(configData);
-    }
-
-    public serviceIsExist(serviceName: string): boolean {
-        const configPath = this.getServiceConfigPath(serviceName);
-        return fs.existsSync(path.dirname(configPath));
-    }
-
-    /**
-     * 获取所有服务配置列表
-     */
-    public listServiceConfigs(): string[] {
-        const confDir = path.join(this.configDir, 'conf.d');
-        
-        if (!fs.existsSync(confDir)) {
-            return [];
-        }
-        
-        const serviceDirs = fs.readdirSync(confDir)
-            .filter(item => {
-                const itemPath = path.join(confDir, item);
-                return fs.statSync(itemPath).isDirectory() && 
-                       fs.existsSync(path.join(itemPath, 'config.ini'));
-            });
-        
-        return serviceDirs;
-    }
-
-    /**
-     * 删除服务配置
-     */
-    public removeServiceConfig(serviceName: string): void {
-        const configPath = this.getServiceConfigPath(serviceName);
-        const configDir = path.dirname(configPath);
-        if (fs.existsSync(configDir)) {
-            fs.rmSync(configDir, { recursive: true });
-        }
-    }
-
-    /**
-     * 更新服务配置
-     */
-    public updateServiceConfig(serviceName: string, updates: Partial<SSHServiceConfig>): void {
-        const config = this.loadServiceConfig(serviceName);
-        const updatedConfig = { ...config, ...updates };
-        this.saveServiceConfig(serviceName, updatedConfig);
-    }
-
-    /**
-     * 验证 keystore 密码
-     */
-    public async validateKeystorePasswords(
-        keystoreIds: string[],
-        passwords: { [keystoreId: string]: string }
-    ): Promise<{ [keystoreId: string]: boolean }> {
-        const results: { [keystoreId: string]: boolean } = {};
-        
-        // 这里需要集成 wative-core 的密码验证逻辑
-        const { WativeCore } = require('wative-core');
-        
-        for (const keystoreId of keystoreIds) {
-            try {
-                const password = passwords[keystoreId];
-                if (!password) {
-                    results[keystoreId] = false;
-                    continue;
-                }
-
-                // 尝试创建 WativeCore 实例来验证密码
-                const wativeCore = new WativeCore(this.keystorePath, [keystoreId], [password]);
-                results[keystoreId] = wativeCore.account.isLogin(keystoreId);
-            } catch (error) {
-                results[keystoreId] = false;
-            }
-        }
-
-        return results;
-    }
-
-    /**
-     * 生成默认配置（向后兼容）
-     */
-
-
-    private isValidServiceName(name: string): boolean {
-        return /^[a-zA-Z0-9_-]+$/.test(name) && name.length > 0 && name.length <= 50;
-    }
-
-    private isPortInUse(port: number): boolean {
-        const configs = this.listServiceConfigs();
-        
-        for (const configName of configs) {
-            try {
-                const config = this.loadServiceConfig(configName);
-                if (config.ssh.port === port) {
-                    return true;
-                }
-            } catch (error) {
-                // 忽略无法加载的配置文件
-            }
-        }
-        
-        return false;
-    }
-
-    private async generateServiceKeyPair(serviceName: string): Promise<{ privateKey: string; publicKey: string; passphrase: string }> {
-        const passphrase = this.generateSecurePassphrase();
-        const serviceDir = path.join(this.configDir, 'conf.d', serviceName);
-        
-        // Create service directory if it doesn't exist
-        if (!fs.existsSync(serviceDir)) {
-            fs.mkdirSync(serviceDir, { recursive: true });
-        }
-        
-        const privateKeyPath = path.join(serviceDir, 'server_private_key');
-        const publicKeyPath = path.join(serviceDir, 'server_public_key.pub');
-
-        if (!fs.existsSync(privateKeyPath)) {
-            console.log(`Generating SSH server key pair for service '${serviceName}'...`);
-            execSync(`ssh-keygen -t rsa -b 4096 -f ${privateKeyPath} -N '${passphrase}' -C 'wative_${serviceName}_server'`, { stdio: 'inherit' });
-        }
-
-        return {
-            privateKey: privateKeyPath,
-            publicKey: publicKeyPath,
-            passphrase: passphrase
-        };
-    }
-
-    private async generateClientKeyPair(serviceName: string, clientName: string): Promise<{ privateKey: string; publicKey: string; passphrase: string }> {
-        const serviceDir = path.join(this.configDir, 'conf.d', serviceName);
-        
-        // Create service directory if it doesn't exist
-        if (!fs.existsSync(serviceDir)) {
-            fs.mkdirSync(serviceDir, { recursive: true });
-        }
-        
-        const publicKeyPath = path.join(serviceDir, `${clientName}.pub`);
-        
-        // Note: We don't generate client private key here, only specify the public key path
-        // The client public key should be provided by the user
-        return {
-            privateKey: '', // Client private key is not stored on server
-            publicKey: publicKeyPath,
-            passphrase: '' // No passphrase needed for public key
-        };
-    }
-
-    private generateSecurePassphrase(): string {
-        return crypto.randomBytes(32).toString('hex');
-    }
-
-    private getServiceConfigPath(serviceName: string): string {
-        return path.join(this.configDir, 'conf.d', serviceName, 'config.ini');
-    }
-
-    private saveServiceConfig(serviceName: string, config: SSHServiceConfig): void {
-        const configPath = this.getServiceConfigPath(serviceName);
-        const configDir = path.dirname(configPath);
-        
-        // Ensure the service directory exists
-        if (!fs.existsSync(configDir)) {
-            fs.mkdirSync(configDir, { recursive: true });
-        }
-        
-        const configText = ini.stringify(config);
-        fs.writeFileSync(configPath, configText);
-    }
-
-    private parseConfigData(configData: any): SSHServiceConfig {
-        return {
-            name: configData.name,
-            description: configData.description,
-            ssh: {
-                listen: configData.ssh.listen,
-                port: parseInt(configData.ssh.port),
-                log: {
-                    size: parseInt(configData.ssh.log.size),
-                    backups: parseInt(configData.ssh.log.backups)
-                }
-            },
-            keystore: {
-                path: configData.keystore.path,
-                allowed_keystores: Array.isArray(configData.keystore.allowed_keystores) 
-                    ? configData.keystore.allowed_keystores 
-                    : configData.keystore.allowed_keystores.split(',')
-            },
-            clients: Array.isArray(configData.clients) 
-                ? configData.clients 
-                : [configData.clients],
-            server_keys: {
-                private_key_path: configData.server_keys.private_key_path,
-                passphrase: configData.server_keys.passphrase
-            }
-        };
-    }
-}