pindo 5.4.0 → 5.5.0

data/lib/pindo/client/pgyer_feishu_oauth_cli.rb

@@ -1,669 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'webrick'
-require 'json'
-require 'net/http'
-require 'uri'
-require 'securerandom'
-require 'digest'
-require 'base64'
-require 'fileutils'
-require 'pindo/base/aeshelper'
-require 'pindo/config/pindouserlocalconfig'
-require 'pindo/client/httpclient'
-
-module Pindo
- 
-  class PgyerFeishuOAuthCLI
-    attr_reader :access_token, :username, :expires_at
-
-    def initialize(client_id)
-      @client_id = client_id
-      @feishu_auth_url = 'https://passport.feishu.cn/suite/passport/oauth/authorize?'
-
-      # 保持原有的redirect_uri，飞书OAuth流程中仍使用这个URL
-      # 前端UI会检测state=terminal_login并自动跳转到localhost:8899
-      @redirect_uri = 'https://pgyerapps.com/login'
-      @pgyer_api_endpoint = 'https://api.pgyerapps.com/api/user/lark_qr_login'
-
-      @state = 'terminal_login'
-      @server_port = 8899
-
-      @larkScopeList = [
-        'task:task:write',
-        'task:section:write',
-        'task:custom_field:write',
-        'task:tasklist:write'
-      ];
-
-      @access_token = nil
-      @username = nil
-      @expires_at = nil
-    end
-
-    # 启动授权流程
-    def authorize
-      # 不再检查已存储的令牌，直接开始授权流程
-      authorization_uri = build_authorization_uri
-      puts "🚀 正在打开浏览器进行飞书 OAuth 授权..."
-      puts "\n📋 授权链接（如浏览器未自动打开，请手动复制访问）:"
-      puts "-" * 60
-      puts authorization_uri
-      puts "-" * 60
-
-      # 在浏览器中打开授权URL
-      open_browser(authorization_uri)
-
-      # 启动本地服务器处理回调
-      code = start_callback_server
-
-      # 如果自动获取失败，提示用户手动输入
-      if code.nil?
-        # 停止任何可能的 spinner 动画
-        if defined?(Funlog) && Funlog.instance.instance_variable_get(:@spinner_log)
-          Funlog.instance.instance_variable_set(:@spinner_log, nil)
-        end
-
-        loop do
-          puts "\n⚠️  自动获取授权码失败，请选择操作："
-          puts "  1. 输入授权码（复制 code= 后的内容）"
-          puts "  2. 输入完整回调 URL"
-          puts "  3. 重新打开授权网页"
-          puts "  4. 退出登录"
-          print "请选择 (1-4): "
-          STDOUT.flush  # 确保提示符立即显示
-
-          begin
-            choice = STDIN.gets&.chomp
-
-            # 处理 Ctrl+C 中断
-            if choice.nil?
-              puts "\n\n🚪 用户中断操作"
-              return :user_cancelled
-            end
-
-            case choice
-            when "1"
-              puts "\n请输入授权码:"
-              print "🔑 "
-              STDOUT.flush  # 确保提示符立即显示
-              code_input = STDIN.gets&.chomp
-              if code_input.nil?
-                puts "\n🚪 用户中断操作"
-                return :user_cancelled
-              elsif !code_input.empty?
-                code = code_input
-                break
-              else
-                puts "⚠️  授权码不能为空，请重新选择"
-              end
-            when "2"
-              puts "\n请输入完整回调 URL:"
-              print "🔗 "
-              STDOUT.flush  # 确保提示符立即显示
-              url_input = STDIN.gets&.chomp
-              if url_input.nil?
-                puts "\n🚪 用户中断操作"
-                return :user_cancelled
-              elsif url_input.start_with?("http")
-                # 尝试从 URL 中提取 code
-                begin
-                  uri = URI(url_input)
-                  query_params = URI.decode_www_form(uri.query || '').to_h
-                  code = query_params['code']
-                  if code
-                    puts "✅ 成功从 URL 提取授权码"
-                    break
-                  else
-                    puts "❌ URL 中未找到授权码，请重新选择"
-                  end
-                rescue => e
-                  puts "❌ 解析 URL 失败: #{e.message}"
-                end
-              else
-                puts "❌ 无效的 URL 格式，请重新选择"
-              end
-            when "3"
-              # 重新打开授权网页
-              puts "\n🔄 重新打开授权网页..."
-              open_browser(authorization_uri)
-              # 重新启动服务器尝试获取授权码
-              code = start_callback_server
-              if code
-                break
-              end
-              # 如果还是失败，继续循环让用户选择
-            when "4"
-              puts "\n🚪 已取消登录"
-              return :user_cancelled
-            else
-              puts "❌ 无效的选择，请输入 1-4"
-            end
-          rescue Interrupt
-            puts "\n\n🚪 用户中断操作"
-            return :user_cancelled
-          end
-        end
-      end
-
-      if code
-        puts "\n✅ 成功获取授权码"
-        print "🔄 正在验证飞书身份..."
-        STDOUT.flush
-        if login_pgyer_with_feishu(code:code)
-          puts " ✅"
-          puts "🎉 登录成功！欢迎使用 Pgyer"
-          # 登录成功后，返回true，外部程序可以通过访问access_token属性获取token
-          return true
-        end
-        return false
-      else
-        puts "\n❌ 授权失败"
-        return false
-      end
-    end
-
-    # 验证Pgyer令牌
-    def validate_pgyer_token(token = nil, expires_at = nil)
-      token_to_check = token || @access_token
-      expiration_time = expires_at || @expires_at
-      
-      # 首先检查token是否存在
-      return false unless token_to_check
-      
-      # 然后检查token是否过期
-      if expiration_time && Time.now.to_i > expiration_time
-        puts "令牌已过期，需要重新登录"
-        return false
-      end
-      
-      # 最后验证token是否有效
-      uri = URI("https://www.pgyer.com/api/user/profile")
-      request = Net::HTTP::Get.new(uri)
-      request['Authorization'] = "Bearer #{token_to_check}"
-      
-      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
-        http.request(request)
-      end
-      
-      return response.code == '200'
-    end
-
-    # 使用code登录Pgyer, 并且Pgyer返回token
-    def login_pgyer_with_feishu(code: nil)
-      return false unless code
-      
-      # 构造请求体
-      body_params = {
-        code: code,
-        redirectUri: @redirect_uri,
-        scope: @larkScopeList.join(' ')
-      }
-      
-      # 使用HttpClient发送请求
-      con = HttpClient.create_instance_with_proxy
-
-      begin
-        res = con.post do |req|
-          req.url @pgyer_api_endpoint
-          req.headers['Content-Type'] = 'application/json'
-          req.body = body_params.to_json
-        end
-        
-        # 处理响应
-        result = nil
-        if !res.body.nil?
-          begin
-            result = JSON.parse(res.body)
-            # puts "解析后的响应: #{result.inspect}"
-            
-            if result['code'] == 200 && !result['data'].nil? && !result['data']['token'].nil?
-              @access_token = result['data']['token']
-              @username = result['data']['username'] if result['data']['username']
-              # 设置token有效期为7天后
-              @expires_at = Time.now.to_i + 6 * 24 * 60 * 60  # 7天的秒数
-              return true
-            else
-              error_msg = result['meta'] && result['meta']['message'] ? result['meta']['message'] : '未知错误'
-              puts " ❌"
-              puts "登录失败: #{error_msg}"
-              return false
-            end
-          rescue => e
-            puts " ❌"
-            puts "响应解析失败: #{e.message}"
-            return false
-          end
-        else
-          puts " ❌"
-          puts "服务器返回空响应"
-          return false
-        end
-      rescue => e
-        puts " ❌"
-        puts "网络请求失败: #{e.message}"
-        return false
-      end
-    end
-
-    private
-
-    # 获取跨平台的 null 设备路径
-    def get_null_device
-      case RbConfig::CONFIG['host_os']
-      when /mswin|mingw|cygwin/
-        'NUL'
-      else
-        '/dev/null'
-      end
-    end
-
-
-    # 构建授权URI
-    def build_authorization_uri
-      uri = URI(@feishu_auth_url)
-
-      params = {
-        'client_id' => @client_id,
-        'redirect_uri' => @redirect_uri,
-        'response_type' => 'code',
-        'state' => @state,
-        'scope' => @larkScopeList.join(' ')
-      }
-      
-      uri.query = URI.encode_www_form(params)
-      uri.to_s
-    end
-
-    # 在浏览器中打开URL
-    def open_browser(url)
-      case RbConfig::CONFIG['host_os']
-      when /mswin|mingw|cygwin/
-        # Windows: 使用双引号包围URL避免参数解析问题
-        system("start \"\" \"#{url}\"")
-      when /darwin/
-        system("open", url)
-      when /linux|bsd/
-        system("xdg-open", url)
-      else
-        puts "无法自动打开浏览器，请手动访问: #{url}"
-      end
-    end
-
-    # 启动本地服务器处理回调
-    def start_callback_server
-      code = nil
-
-      # 检查并处理端口占用
-      unless ensure_port_available(@server_port)
-        puts "✗ 无法使用端口 #{@server_port}，登录失败"
-        return nil
-      end
-
-      puts "\n🌐 本地服务器已启动（端口: #{@server_port}）"
-      puts "💡 提示: 按 Ctrl+C 可中断并选择其他操作"
-      puts "🔄 等待飞书授权回调..."
-
-      begin
-        # 使用本地8899端口处理回调，不管redirect_uri配置如何
-        server = WEBrick::HTTPServer.new(
-          Port: @server_port,
-          BindAddress: '127.0.0.1',
-          Logger: WEBrick::Log.new(get_null_device),
-          AccessLog: []
-        )
-      rescue Errno::EADDRINUSE
-        puts "✗ 端口 #{@server_port} 仍被占用，无法启动服务器"
-        return nil
-      rescue Errno::ENOENT
-        puts "✗ 启动服务器失败: 系统找不到指定的路径或文件"
-        return nil
-      rescue => e
-        puts "✗ 启动服务器失败: #{e.message}"
-        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-          puts "  提示: 如果是Windows系统，请确保防火墙允许Ruby访问网络"
-        end
-        return nil
-      end
-
-      # 处理根路径的请求
-      server.mount_proc '/' do |req, res|
-        begin
-          # puts "接收到请求: #{req.request_line}"
-          # puts "请求参数: #{req.query_string}"
-          
-          # 安全解析请求参数
-          begin
-            query_params = URI.decode_www_form(req.query_string || '').to_h
-            # 只在有code时输出日志，避免多余信息
-            # puts "解析的参数: #{query_params.inspect}" if query_params['code']
-          rescue => e
-            # puts "解析请求参数失败: #{e.message}"
-            query_params = {}
-          end
-          
-          # if query_params['state'] != @state
-          #   puts "状态不匹配: 接收到 #{query_params['state']}，期望 #{@state}"
-          #   res.content_type = "text/html; charset=UTF-8"
-          #   res.body = "状态不匹配，可能存在CSRF攻击风险"
-          # elsif query_params['error']
-          if query_params['error']
-            # puts "授权错误: #{query_params['error']}"
-            res.content_type = "text/html; charset=UTF-8"
-            res.body = "授权错误: #{query_params['error']}"
-          elsif query_params['code']
-            code = query_params['code']
-            # 成功获取时不输出，避免重复
-            # puts "成功获取授权码: #{code}"
-            res.content_type = "text/html; charset=UTF-8"
-            res.body = <<-HTML
-            <!DOCTYPE html>
-            <html>
-            <head>
-              <meta charset="UTF-8">
-              <title>飞书授权成功</title>
-              <style>
-                body { font-family: Arial, sans-serif; text-align: center; padding: 40px; }
-                .container { max-width: 600px; margin: 0 auto; }
-                .success { color: #4CAF50; }
-                .code { font-family: monospace; background: #f5f5f5; padding: 10px; border-radius: 4px; word-break: break-all; }
-                .countdown { font-weight: bold; color: #FF5722; }
-                .autoclose-banner { 
-                  background-color: #333; color: white; padding: 10px; 
-                  position: fixed; top: 0; left: 0; right: 0;
-                  display: flex; justify-content: space-between; align-items: center;
-                }
-                .close-btn {
-                  background: #f44336; color: white; border: none;
-                  padding: 5px 10px; cursor: pointer; border-radius: 3px;
-                }
-              </style>
-              <script>
-                // 尝试多种方法关闭窗口
-                function attemptClose() {
-                  try {
-                    // 方法1: 最基本的关闭尝试
-                    window.close();
-                    
-                    // 方法4: 尝试使用opener关系
-                    if (window.opener) {
-                      window.opener.focus();
-                      window.close();
-                    }
-                    
-                    // 如果以上方法都失败了，显示手动关闭提示
-                    setTimeout(function() {
-                      document.getElementById('close-message').style.display = 'block';
-                      document.getElementById('countdown-container').style.display = 'none';
-                    }, 1000);
-                  } catch (e) {
-                    console.error("关闭窗口失败:", e);
-                    document.getElementById('close-message').style.display = 'block';
-                    document.getElementById('countdown-container').style.display = 'none';
-                  }
-                }
-                
-                // 倒计时函数
-                var secondsLeft = 3;
-                function updateCountdown() {
-                  document.getElementById('countdown').innerText = secondsLeft;
-                  if (secondsLeft <= 0) {
-                    attemptClose();
-                  } else {
-                    secondsLeft -= 1;
-                    setTimeout(updateCountdown, 1000);
-                  }
-                }
-                
-                // 初始化
-                window.onload = function() {
-                  updateCountdown();
-                }
-              </script>
-            </head>
-            <body>
-              <div class="autoclose-banner">
-                <span>授权成功! 此窗口将自动关闭 (<span id="countdown" class="countdown">3</span>)</span>
-                <button class="close-btn" onclick="attemptClose()">立即关闭</button>
-              </div>
-              
-              <div class="container">
-                <h1 class="success">飞书授权成功！</h1>
-                <p>已获取授权码，正在返回命令行...</p>
-                
-                <div id="countdown-container">
-                  <p>此窗口将在 <span id="countdown-text" class="countdown">3</span> 秒后自动关闭</p>
-                </div>
-                
-                <div id="close-message" style="display: none;">
-                  <p>自动关闭失败，请手动关闭此窗口</p>
-                  <button class="close-btn" onclick="attemptClose()">尝试再次关闭</button>
-                </div>
-                
-                <p>授权码：</p>
-                <div class="code">#{code}</div>
-              </div>
-              
-              <script>
-                // 同步倒计时显示
-                document.getElementById('countdown-text').innerText = secondsLeft;
-              </script>
-            </body>
-            </html>
-            HTML
-          else
-            # 忽略没有参数的请求（如favicon.ico等）
-            # puts "未获取到授权码"
-            res.content_type = "text/html; charset=UTF-8"
-            res.body = "等待授权中..."
-          end
-
-          # 只在获取到code时关闭服务器
-          if code
-            Thread.new do
-              sleep 4  # 给用户时间看到成功页面
-              server.shutdown
-            end
-          end
-        rescue => e
-          # 静默处理错误，避免干扰用户
-          # puts "处理请求时出错: #{e.class} - #{e.message}"
-
-          # 确保即使出错也返回有效的响应
-          res.content_type = "text/html; charset=UTF-8"
-          res.body = "处理请求时出错"
-        end
-      end
-      
-      # 捕获Ctrl+C以允许用户中断
-      trap('INT') { server.shutdown }
-      
-      # puts "正在监听http://localhost:8899等待飞书重定向..."
-      # puts "您也可以手动访问: http://localhost:8899/?code=YOUR_CODE&state=terminal_login"
-      
-      # 在线程中运行服务器，最多等待3分钟
-      thread = Thread.new { server.start }
-      begin
-        thread.join(180) # 最多等待3分钟
-      rescue Timeout::Error
-        puts "授权超时"
-        server.shutdown
-      end
-
-      # 返回获取到的code（如果有的话）
-      code
-    end
-
-    # 确保端口可用，处理端口占用问题
-    def ensure_port_available(port)
-      return true unless port_occupied?(port)
-
-      puts "⚠️  端口 #{port} 被占用，正在检查占用进程..."
-
-      # 获取占用端口的进程信息
-      process_info = get_port_process_info(port)
-
-      if process_info.nil?
-        puts "✗ 无法获取端口占用信息"
-        return false
-      end
-
-      puts "占用进程信息："
-      puts "  PID: #{process_info[:pid]}"
-      puts "  进程名: #{process_info[:name]}"
-      puts "  命令: #{process_info[:command]}"
-
-      # 检查是否是自己的进程（可能是之前未正常关闭的实例）
-      if process_info[:name].include?('ruby') && (process_info[:command].include?('pindo') || process_info[:command].include?('pgyer'))
-        puts "检测到可能是 Pindo/Pgyer 之前的遗留进程"
-        if ask_user_kill_process?
-          return kill_process_by_pid(process_info[:pid])
-        end
-      else
-        puts "端口被其他应用程序占用"
-        if ask_user_kill_process?
-          return kill_process_by_pid(process_info[:pid])
-        end
-      end
-
-      return false
-    end
-
-    # 检查端口是否被占用
-    def port_occupied?(port)
-      require 'socket'
-
-      begin
-        server = TCPServer.new('127.0.0.1', port)
-        server.close
-        false  # 端口未被占用
-      rescue Errno::EADDRINUSE
-        true   # 端口被占用
-      rescue => e
-        puts "⚠️  检查端口时出错: #{e.message}"
-        true   # 出错时假设端口被占用，避免冲突
-      end
-    end
-
-    # 获取占用指定端口的进程信息
-    def get_port_process_info(port)
-      begin
-        # macOS/Linux 使用 lsof 命令
-        if system('which lsof > /dev/null 2>&1')
-          output = `lsof -ti :#{port} 2>/dev/null`.strip
-          return nil if output.empty?
-
-          pid = output.split("\n").first
-          return nil if pid.nil? || pid.empty?
-
-          # 获取进程详细信息
-          ps_output = `ps -p #{pid} -o pid,comm,args 2>/dev/null`.lines
-          return nil if ps_output.length < 2
-
-          process_line = ps_output[1].strip
-          parts = process_line.split(/\s+/, 3)
-
-          return {
-            pid: parts[0],
-            name: parts[1] || 'unknown',
-            command: parts[2] || 'unknown'
-          }
-        end
-
-        # Windows 使用 netstat 命令
-        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-          output = `netstat -ano | findstr :#{port}`.strip
-          return nil if output.empty?
-
-          lines = output.split("\n")
-          listening_line = lines.find { |line| line.include?('LISTENING') }
-          return nil unless listening_line
-
-          pid = listening_line.split.last
-          return nil if pid.nil? || pid.empty?
-
-          # 获取进程名称
-          task_output = `tasklist /FI "PID eq #{pid}" /FO CSV /NH 2>nul`.strip
-          if !task_output.empty?
-            process_name = task_output.split(',').first.gsub('"', '')
-            return {
-              pid: pid,
-              name: process_name,
-              command: process_name
-            }
-          end
-        end
-
-        return nil
-      rescue => e
-        puts "获取进程信息时出错: #{e.message}"
-        return nil
-      end
-    end
-
-    # 询问用户是否终止占用端口的进程
-    def ask_user_kill_process?
-      puts "\n是否终止占用端口的进程？"
-      puts "  y/yes - 终止进程并继续 (可能影响其他应用)"
-      puts "  n/no  - 取消登录 (默认)"
-      print "> "
-
-      begin
-        response = STDIN.gets&.chomp&.downcase
-        return ['y', 'yes'].include?(response)
-      rescue Interrupt
-        puts "\n\n用户中断操作"
-        return false
-      rescue => e
-        puts "无法读取用户输入: #{e.message}"
-        return false
-      end
-    end
-
-    # 根据 PID 终止进程
-    def kill_process_by_pid(pid)
-      return false if pid.nil? || pid.empty?
-
-      begin
-        puts "正在终止进程 #{pid}..."
-
-        # 跨平台的进程终止命令
-        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-          # Windows
-          success = system("taskkill /PID #{pid} /F >nul 2>&1")
-        else
-          # macOS/Linux - 先尝试优雅终止，再强制终止
-          success = system("kill -TERM #{pid} 2>/dev/null")
-          sleep(2)
-          # 检查进程是否还存在
-          if system("kill -0 #{pid} 2>/dev/null")
-            puts "优雅终止失败，使用强制终止..."
-            success = system("kill -KILL #{pid} 2>/dev/null")
-          end
-        end
-
-        if success
-          puts "✓ 进程 #{pid} 已终止"
-          sleep(1) # 等待端口释放
-
-          # 再次检查端口是否可用
-          unless port_occupied?(@server_port)
-            puts "✓ 端口 #{@server_port} 现在可用"
-            return true
-          else
-            puts "⚠️  端口仍被占用，可能需要等待更长时间"
-            return false
-          end
-        else
-          puts "✗ 终止进程失败，可能需要管理员权限"
-          return false
-        end
-      rescue => e
-        puts "终止进程时出错: #{e.message}"
-        return false
-      end
-    end
-
-  end
-
-end